Microservices

a definition of this new architectural term

The term 'Microservice Architecture' has sprung up over the last few years to describe a particular way of designing software applications as suites of independently deployable services. While there is no precise definition of this architectural style, there are certain common characteristics around organization around business capability, automated deployment, intelligence in the endpoints, and decentralized control of languages and data.

'Microservices' - yet another new term on the crowded streets of software architecture. Although our natural inclination is to pass such things by with a contemptuous glance, this bit of terminology describes a style of software systems that we are finding more and more appealing. Weve seen many projects use this style in the last few years, and results so far have been positive, so much so that for many of our colleagues this is becoming the default style for building enterprise applications. Sadly, however, theres not much information that outlines what the microservice style is and how to do it.

In short, the microservice architectural style [1] is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. These services are built around business capabilities and independently deployable by fully automated deployment machinery. There is a bare minimum of centralized management of these services, which may be written in different programming languages and use different data storage technologies.

My Microservices Resource Guide provides links to the best articles, videos, books, and podcasts about microservices.

To start explaining the microservice style its useful to compare it to the monolithic style: a monolithic application built as a single unit. Enterprise Applications are often built in three main parts: a client-side user interface (consisting of HTML pages and javascript running in a browser on the users machine) a database (consisting of many tables inserted into a common, and usually relational, database management system), and a server-side application. The server-side application will handle HTTP requests, execute domain logic, retrieve and update data from the database, and select and populate HTML views to be sent to the browser. This server-side application is a monolith - a single logical executable[2]. Any changes to the system involve building and deploying a new version of the server-side application.

Such a monolithic server is a natural way to approach building such a system. All your logic for handling a request runs in a single process, allowing you to use the basic features of your language to divide up the application into classes, functions, and namespaces. With some care, you can run and test the application on a developers laptop, and use a deployment pipeline to ensure that changes are properly tested and deployed into production. You can horizontally scale the monolith by running many instances behind a load-balancer.

Monolithic applications can be successful, but increasingly people are feeling frustrations with them - especially as more applications are being deployed to the cloud . Change cycles are tied together - a change made to a small part of the application, requires the entire monolith to be rebuilt and deployed. Over time its often hard to keep a good modular structure, making it harder to keep changes that ought to only affect one module within that module. Scaling requires scaling of the entire application rather than parts of it that require greater resource.

Figure 1: Monoliths and Microservices

These frustrations have led to the microservice architectural style: building applications as suites of services. As well as the fact that services are independently deployable and scalable, each service also provides a firm module boundary, even allowing for different services to be written in different programming languages. They can also be managed by different teams .

We do not claim that the microservice style is novel or innovative, its roots go back at least to the design principles of Unix. But we do think that not enough people consider a microservice architecture and that many software developments would be better off if they used it.

Characteristics of a Microservice Architecture

We cannot say there is a formal definition of the microservices architectural style, but we can attempt to describe what we see as common characteristics for architectures that fit the label. As with any definition that outlines common characteristics, not all microservice architectures have all the characteristics, but we do expect that most microservice architectures exhibit most characteristics. While we authors have been active members of this rather loose community, our intention is to attempt a description of what we see in our own work and in similar efforts by teams we know of. In particular we are not laying down some definition to conform to.

Componentization via Services

For as long as weve been involved in the software industry, theres been a desire to build systems by plugging together components, much in the way we see things are made in the physical world. During the last couple of decades weve seen considerable progress with large compendiums of common libraries that are part of most language platforms.

When talking about components we run into the difficult definition of what makes a component. Our definition is that a component is a uni

剩余内容已隐藏，支付完成后下载完整资料

---

微服务架构的定义

“微服务架构”(Microservice Architecture)一词在过去的几年间涌现出来，作为一套可以独立部署的服务，用来描述一种特殊的设计软件应用的方式。虽然没有这个架构风格没有明确的定义，但围绕业务功能的组织，自动部署（automated deployment），端智能(intelligence in the endpoints,)以及对语言和数据的分散控制存在某些共同的特征。

“微服务”，又一个出现在众多软件架构术语中的新词。虽然我们主观倾向于对这样的概念不屑一顾， 但这个词描述了一种让我们觉得越来越有吸引力的软件系统风格。我们已经看到在过去的几年间有多个项目使用这种风格，到目前为止，结果都是乐观的。以至于这已经逐渐成为了我们很多同事在构建企业级应用的默认方式。然而，遗憾的是，并没有太多的信息去概述什么是微服务以及如何去做。

简而言之，微服务架构风格就是将单一应用的开发分为多个小的服务，每个小的服务在自己的进程中运行并使用轻量级机制进行通信（通常是一个HTTP API源），这些服务围绕业务性能进行构建，并且通过完全自动化的部署机制独立的部署。这些只需要最低限度的集中管理的服务，可以使用不同的编程语言编写，以及使用不同的数据存储技术。

为了阐述微服务架构，有必要让其与Monolithic架构进行比较：一个Monolithic应用由一个单元构建。企业级应用通常由三部分构建：客户端界面（包括HTML页面和运行在客户机器上浏览器里的javascript脚本），数据库（许多表构成的、相互关联的关系型数据库管理系统）以及一个服务器端应用。服务器端应用处理HTTP请求，执行域逻辑（domian logic），从数据库中查询和更新数据，选择并填充将要发送到浏览器的视图。这个服务器端程度就是一个Monolithic - 单一的逻辑上可执行的应用。对这个系统的任何更改都会构建和部署一个服务器端应用的新版本。

Monolithic架构是构建这样一种系统很自然的方式。处理请求的逻辑都在一个单一的进程中，允许你使用编程语言的基本特性将应用分割为类，函数以及命名空间。在某些场景中，你可以在开发人员的计算机运行和测试应用，并使用部署管道来确保对更改进行正确的测试以及部署到生产环境中。你也可以横向扩展Monolithic应用，通过负载均衡将多个应用部署到多个服务器上。

Monolithic架构能够成功 ， 但是越来越多的对其感到失望， 特别是越来越多的应用被部署到cloud中。变更周期被绑定了，对应用一个小的更改，将会重新构建者部署整个项目。随着时间的推移，通常很难保持一个良好的模块化结构，这使得更改时只影响应用的一个小模块变得更加困难，扩展时需要扩展整个应用，而不只是进行部分部署。

Monolithic架构的这些缺陷导致了Microservices架构的出现：通过一系列的服务去构建应用。服务除了可以独立部署和可扩展之外，每个服务还有固定的模块边界，甚至允许使用不同的语言去编写不同的服务。它们也能被不同的团队进行管理。

我们并不主张说Microservices架构是多么新的东西，它至少可以追溯到Unix设计规范之前。但是我们确实认为没有足够的人去考虑Microservices架构，如果他们使用Microservices架构，很多软件系统将会变得更好。

微服务架构的特征

我们不能说微服务架构有一个正式的定义，但我们可以去尝试描述与“微服务”这个标签相匹配的体系架构的共同特征。正如用一个定义概括任何其他具有共同特征的事物一样，并非所有的微服务架构具有这些所有的特征，但我们确实希望所有的微服务架构具有大多数的这些特征。

尽管笔者们已经是这个相当松散的社区的积极成员，我们的意图是尝试去描述在我们自己的工作中所发现的，以及我们所知道的其他团队类似的努力。特别是我们没有下明确的定义遵守这个架构的时候。

——————————————————————————————————

组件化（Componentization） 与服务 (Service)

自从我们开创软件行业以来，就会一直希望将组件连接在一起的方式去构建系统，就像我们在物理世界中所看见的一样。在过去的几十年中，我们看见了大量简编的公共库取得的巨大进步，它们是大多数语言平台的一部分。

在谈论组件时，我们遇到了定义上的难题即什么构成了组件。我们的定义是，组件是一个独立的，可替换的和可升级的软件单元 。

微服务架构会使用库，但是其组件化自身软件的主要方式是将其拆分为服务。我们将库定义为连接到程序中的组件，并使用内存中的函数进行调用，而服务则是进程外的组件，这些组件通过webservice请求或者远程过程调用（RPC）等机制进行通信。（组件和服务在很多面向对象编程中是不同的概念）

使用服务作为组件（而不是库）的主要原因是服务是可以独立部署的。如果你的应用由单个进程中的多个库组成，则对单个组件的任何更改都将导致不得不重新部署整个应用。但是，如果将应用分解为多个服务，你可以期望单个服务的更改只需要重新部署该单个服务即可。当然，这也不是绝对的，一些更改将改变服务接口，从而会产生一些协调。但是优秀的微服务架构的目的是通过服务契约中的解耦服务边界和进化机制将这些更改最小化 。

使用服务作为组件的另一个结果是更显式的组件接口。 大多数语言都没有良好的机制来定义显式的发布接口。通常只有文档化和规则才能防止用户破坏组件的封装，从而避免组件之间的紧密耦合。通过使用显式的远程调用机制，服务可以更容易的避免这种这种情况。

使用这样的服务确实有缺陷。远程调用比在进程内调用更消耗资源，由于远程API需要粗粒度的，这通常更难于使用。如果你需要更改服务之间的职责分配，那么当你跨越进程边界时，这种行为方式将会变得更加困难。

在第一种类似情况中，我们注意到服务映射到运行时进程，但这只是第一种类似情况。服务可以由多个进程组成，这些进程将始终被开发和部署在一起，例如应用程序进程和仅由该服务使用的数据库 。

——————————————————————————————————

围绕业务功能组织

当将一个大型应用分为多个部分时，通常管理会集中在技术层面，UI团队，服务端团队和数据库团队。当团队沿着这条线分开时，即使是简单的变更也会导致跨团队间的项目时间和预算审批的花费。一个聪明的团队会优化这个问题-两害相权取其轻-只需将逻辑置于它们想要访问的应用中。换句话说，逻辑无处不在。这是Conway定律得一个例子。

微服务的划分方法是不同的，它倾向于围绕业务功能的组织来分割服务。此类服务对该业务领域进行了广泛的软件实现，包括用户界面、持久化存储和任何的外部协作。因此，团队是跨职能的，包括开发过程所需的全部技能：用户体验、数据库和项目管理。

有一个以这样的方式进行组织的公司 ：www.comparethemarket.com 。跨功能团队负责构建和执行每个产品，并将每个产品分割成多个单独的服务，通过消息总线进行通信。

大型的Monolithic应用也可以围绕业务功能进行模块化，尽管这不是常见的情况。 当然，我们会敦促一个构建Monolithi应用的大型团队，以便将其沿着业务线进行划分。

我们在这里看到的主要问题是，这种组件形式会导致太多的依赖。如果Monolithic跨越了许多模块化的边界，那么团体的个体成员很难将其融入到他们的短期记忆中。此外，我们还发现，模块化需要大量的规则来执行。服务组件要求的分割越明确，使得保持团队之间的界限变得越容易。

——————————————————————————————————

微服务有多大？

尽管“微服务”已经成为了这种架构风格的流行名称，但是它的名字确实导致了对服务规模的不幸关注，以及关于什么构成“微”的争论。在我们与微服务实践者的交流中，我们看到了一系列服务的大小。 据报道，

最大的规模遵循了亚马逊“Two Pizza Team”的概念（即整个团队两个比萨就够了），也就是不超过12个人。在规模较小的团队里，我们看到的是小规模的团队提供小规模的服务这种配置。

这样就引出了一个问题：在这个范围内是否存在足够大的差异，即每个成员的服务和每个团队的服务的大小不应该被归入一个微服务标签。目前，我们认为最好将它们组合在一起，但当我们进一步探索这种架构风格时 ，我们当然有可能改变我们的想法。

——————————————————————————————————

产品不是项目

我们看到的大多数应用开发工作都使用了一个项目模型：目的是为了交付一些软件，然后就被认为是完成了。软件完成后被移交给维护部门，构建软件的项目组解散。

微服务的支持者们倾向于避免这种模式，他们更倾向于一个团队应该负责产品的整个生命周期。这是一个共同的灵感，是亚马逊“你构建，你运维”的概念，一个开发团队对软件的开发承担全部的责任。

这使得开发人员每天接触到他们的软件在开发过程中的行为，并增加与用户的联系，因为他们至少要承担一些售后支持负担。

产品的理念，与业务功能联系在一起。并不只是将软件看成一组要完成的功能，还有一个持续性的问题，即软件如何帮助用户提高其业务能力。

我们并没有理由不能使用Monolithic应用，但是服务的粒度越小，就越容易在服务提供者和用户之间建立紧密关系。

——————————————————————————————————

强化终端及弱化通道（Smart endPoints and dumb pipes）

在构建不同进程间的通信结构时，我们发现很多产品和方法能够更加有效的将其自身加入到通信机制中。其中一个很好的例子是企业服务总线(ESB)，ESB产品通常包括用于消息路由，编排，转换和应用业务规则。

微服务社区支持的另一种方法：强化终端及弱化通道 。从微服务中构建的应用的目标是尽可能的解耦和尽可能的内聚-它们拥有自己的域逻辑，就像在经典的Unix意义上的过滤器-接收请求，适当的应用逻辑并生成响应。这些都是使用简单的RESTish协议编排的，而不是像WS-Choreorgaphy或BPE或者由集中式框架编制的复杂协议，最常见的两种协议是携带资源的HTTP请求-响应以及轻量级的消息传递。

——————————————————————————————————

微服务和SOA

当我们讨论微服务时，一个常见的问题是：这是否仅仅就是我们10年前看到的面向服务的架构（SOA）。这一点是有价值的，因为微服务的风格非常类似于SOA的一些支持者所倡导的。然而，问题是SOA意味着太多不同的东西，而且大多数时候我们遇到的东西被成为“SOA”，它与我们在这里描述的风格有很大的不同，通常是因为ESB用于集成Monolithic应用。

特别是我们已经看到了许多面向服务的拙劣实现-从ESB中隐藏复杂性的倾向-到那些花费数百万美元但并无交付价值，到积极抑制改变的集中管理模式，有时很难看到过去的这些问题。

当然，在微服务中使用的许多技术都是从在大型组织中集成服务的开发人员的经验中成长起来的。Tolerant Reader模式就是一个例子。使用web的努力已经做出了贡献，使用简单的协议是从这些经验中获得的另一种方法 - 从那些已经达到复杂性的中心标准，坦率的说，是惊人的。（任何时候，你需要一个本体来管理你的本体，你知道你身陷困境）。

SOA的这一常见表现致使一些微服务的拥护者完全拒绝SOA，尽管其他人认为微服务是SOA的一种形式，或许面向服务是正确的。无论怎样，SOA都意味着不同的东西，这意味着又一个更清晰的定义这个架构风格的术语是很有价值的。

微服务团队使用万维网（很大程度上是Unix）构建的原则和协议。经常使用的资源可以通过开发人员或者操作人员很少的努力来缓存。

第二种方式是在轻量级消息总线上进行消息传递。这种通信协议非常单一（单一到只负责消息路由）- 简单的实现比如 RabitMQ 和ZeroMQ甚至没有提供可靠的异步机制，以至于需要依赖产生或者消费信息的终端或者服务来处理这类问题。

在Monolith架构中，组件在进程中执行，它们之间的通信通过方法调用或者函数调用来进行。将Monolith架构转换为微服务架构的最大问题在于改变通信模式。从内存调用到RPC的转换会导致不好的信息通信。相反，你需要使用粗粒度的通信方式来代替细粒度的通信。

——————————————————————————————————

去中心化管理

去中心化管理的结果之一是在单一的技术平台上进行标准化的趋势。经验表明，这种方法是相对的-并不是所有的问题都是钉子，并不是每个解决方案都是锤子。我们更喜欢使用合适的工具来来完成工作，而Monolithic应用可以在一定程度上利用不同的语言，这并不常见。

将Monolithic的组件拆分为服务，我们可以在构建它们的时候有一个选择。你想要使用Node.js来建立一个报表页面？去吧！对于一个几乎接近实时的组件使用C ? 很棒。你想要换一种不同的数据库，以便更好的适应一个组件的读取行为吗？我们有重新构建它的技术。

当然，仅仅是因为你可以这样做，并不意味着你应该这样做-但是以这种方式划分的系

剩余内容已隐藏，支付完成后下载完整资料

---

资料编号：[236593]，资料为PDF文档或Word文档，PDF文档可免费转换为Word