Micro-service--martin Flower "translation"

Original address

Content of this article

• Micro-Service
• Micro-service style features
• Components and Services
• Organize around business functions
• Product is not a project
• Strengthen the terminal and weaken the channel
• Decentralized governance
• Decentralized data management
• Infrastructure automation
• Design of fault tolerance
• Design improvements
• is micro-service the future?
• Other
• How large is the microservices system
• MicroServices and SOA
• Multi-lingual and multi-choice
• Practice standards and mandatory standards
• Make it easier to do things
• Circuit breakers circuit Breaker and existing code in the product
• Synchronization is harmful

Micro-Service

The term "microservices architecture" has been widely disseminated over the past few years, and it is used to describe a design approach to software applications that are deployed independently. There is no very precise definition of this architecture, but there are significant features in business capability, automatic deployment, end-to-end integration, and decentralized control of language and data.

MicroServices----Just a term in the software architecture that fills the streets. Although we despise this kind of thing very much, but this thing describes the software style, more and more attracted our attention. Over the past few years, we have found that more and more projects are beginning to use this style, so that colleagues around us take it for granted as a default development form when building enterprise applications. Unfortunately, however, the micro-service style is what it should be and how it should be developed, but it is hard to find a theoretical description.

In short, the MicroServices architecture style is like developing small services into a single application, each running in a single process and using a lightweight API such as HTTP. These services meet a requirement and are released independently using automated deployment tools. These services can use different development languages, as well as different data storage technologies, and maintain centralized management with minimal restrictions.

Before starting the micro-service style, first introduce the overall style: that is, a complete application as a development unit. Enterprise applications typically consist of three parts: a Client interface (composed of HTML, JavaScript, accessed using a browser), a database (consisting of many table components as a common, interconnected data management system), and a server-side application. The server application processes the HTTP request, executes the realm logic, retrieves and updates the data in the database, and sends it to the client using the appropriate HTML view. Server-side applications are complete----executed at a single logical level. Task changes in the system will be re-edited and published in a new version by the application on the server side.

Such a holistic service is a natural way to build a system. While the use of the development language base feature encapsulates an application into classes, functions, and namespaces, all the logic in the business is handled in a single process. In some scenarios, developers may develop and test applications in the pen-based book, and then use the deployment channel to ensure that the product is released correctly after a normal test and release of the modified content. You can also use scale-out to deploy conceal things applications across multiple servers through a load-homogeneous system.

The overall style of application is also quite successful, but more and more people feel a little bit inappropriate, especially when it comes to publishing applications in the cloud. The change release cycle is bound----can be divided into small applications, small needs changes, and need to be compiled and published uniformly. Over time, it is often difficult to maintain a graceful modular structure, making it difficult for a module to change without affecting other modules. Expansion, it also needs to be expanded as a whole, not as part of the expansion.

Figure 1: Organizing the architecture and MicroServices architecture

These reasons have led to the advent of MicroServices architecture styles: Building Applications with services. Because services can be deployed independently and independently, the service can also provide a modular boundary, and different uses can use different development languages. The service can also be managed in different cycles.

The microservices style is not invented by us, nor is it a new thing, it originates from the design principles of the Unix age at least. In this way, we think that only a few people have considered this style at the time, and realize that the use of this style of software can bring more benefits.

Micro-service style features

There is no way to define the microservices style exactly, but we can try to describe the characteristics of the micro-service style that it should have, so that it can be labeled accordingly. Just as the description of features in other definitions is new, not all microservices styles have all the features, but we think common microservices should have these features. Although we are fairly loosely core members of the community, we also plan to try to describe the microservices that we understand in our work or in other components we understand. Of course, we do not rely on definitions that have been explicitly defined.

Components and Services

Ever since we've been in the software industry, we've wanted to be able to build systems of components, just as we've seen the implementation of the world made up of objects. In the past few decades, we have seen the simplification of the public libraries of most language platforms and have made considerable progress.

When we talk about components, it is possible to cause confusion because of the different definitions of the components. So we affirm that the component referred to here refers to a separate unit in the software that can be independently replaced and updated independently.

The MicroServices architecture also uses a component library, but it splits the software into services and considers it to be the primary form of organization. We define the component libraries as relationships in programs, and use components called in memory to define services as components that are used between processes, such as Web request services or remote calls to communicate with each other. (This definition is not the same as the concept of a service object in other object-oriented programs.) ）

The main reason for treating services as components rather than component libraries is that services can be deployed independently. If your app consists of multiple component libraries and runs in one process, any changes to the component will result in a re-release of the overall app. But if the application is made up of many services, you can imagine that the changes to each service only need to publish the appropriate service. Of course, this is not absolute, such as the change of service interface will require the change of the corresponding service, but excellent microservices architecture, will try to avoid the coupling between this service and improve the interface of the service.

Another consideration for serving as a component is that it will have an updated interface. Many development languages do not have a good mechanism for defining public interfaces. Typically only documentation and specification instructions allow users to avoid excessive dependencies between components that can lead to component coupling. But the service is made by explicit remote interface calls, the problem is easy to solve.

The use of the service also has its shortcomings. Remote calls consume more performance than incoming internal calls, and remote APIs are rough and difficult to use. This can be difficult if you change the responsibilities of a component and affect cross-process interactions.

The first possible feature that we see is that each service is running on a separate process. Note that this is only the first possible feature. Services can also be made up of multiple processes that are developed and deployed at the same time, such as a service that may be used in an application and a data-based approach.

Organize around business functions

When looking to split a large application into smaller parts, supervisors usually pay attention to the technical level, split into UI groups, service logical groups, and database groups. When you use this standard to divide teams, even small notconsistent will lead to collaboration across team projects, consuming time and budget approvals. An efficient team will improve on this situation, focus on the application logic they are involved in, and make better choices from it. In other words, logic is everywhere. The practice of Conway's law is an example.

Any organization that designs a system (a system in its broadest sense) produces a design whose structure is a copy of its organization's communication structure.
--melvyn Conway, 1967

Figure 2:conway ' s law practice

MicroServices are more inclined to divide and dismantle service structures around business functions . This service is a complete implementation of the software for the business domain, it contains the use of interfaces, persistent storage, and the interaction of the Lent. The team should therefore be cross-functional and contain complete development techniques: User experience, database, and project management.

Figure 3: Emphasizing service boundaries through team boundaries

This form of organization is used by www.comparethemarket.com. Teams of different functions are also responsible for their own product build and operation, while each product is split into multiple separate services that communicate through the Messaging engine.

Large-scale monolithic applications can also be modular in terms of business functions, although this is not a common example. Of course, we urge a large team to split an application that is built into a monolithic form according to the business function. The main problem we can see is that this form of component leads to a lot of contextual dependencies. If this large number of calls exist on a large number of module boundaries, it is difficult to remember for each member of the team in the short term. In addition, we find that modularity requires a lot of specification to enforce, and of course, a large number of clear splits also make the service components clearer in the boundaries of the team.

Product is not a project

Most software developers use this development pattern: to force the provision of software that is considered complete. Once the development is complete, the software is handed over to the maintenance department, and the development team can be disbanded.

Proponents of microservices argue that this approach is undesirable and suggests that the development team should be responsible for the entire life cycle of the product. A common proof is that Amazon's "You compile, your OPS (you build, you run it)" concept, which requires the development team to be responsible for the entire life cycle of the SOFTWARE PRODUCT. This requires the developer to focus on the operation of the SOFTWARE product every day, and to connect with the user more closely, while assuming some after-sales support.

Mature products are tied to business functions. In addition to seeing software as a set of established functions, it is more concerned with the question of how software helps users achieve business functions.

There is no reason to adopt a monolithic architecture, but the smaller the granularity of service, the easier it is to promote the relationship between the user and the service provider.

Strengthen the terminal and weaken the channel

When we build different inter-process communication mechanisms, we find that there are many products and methods that can put more effective methods into the communication mechanism. such as Enterprise Service Bus (ESB), which provides a more efficient way to improve routing, encoding, transmission, and business processing rules in the communication process.

MicroServices tend to make the following choices: hardening the terminal and weakening the channel. The application of microservices is dedicated to loose coupling and high cohesion: Adopting separate business logic that behaves more like a filter in the classic UNIX sense, accepting requests, processing business logic, and returning responses. They prefer a simple rest style, rather than a complex protocol, such as WS or BPEL or a centralized framework.

There are two types of protocols that are most often used: request-response and lightweight message communication protocols that contain HTTP for resource APIs. The most important recommendations are:

Being of the web, not behind the Web (good at using the network rather than restricting it.) )

--ian Robinson

The MicroServices team uses the principles and norms of building systems based on the Internet (broadly, including UNIX systems). This often used resources can be cached by developers or operators at little cost.

The second approach is to publish messages through a lightweight message bus. This kind of communication protocol is very single (single to only responsible for message routing), simple implementations such as RABBITMQ or ZEROMQ are not even available as reliable asynchronous mechanisms, so they need to rely on terminals or services that produce or consume messages to handle such problems.

In a holistic style, components are executed in-process, and inter-process message communication is usually done by invoking a method or a callback function. The biggest problem from the monolithic style to the microservices framework is the change in communication patterns. The original call from inside the memory becomes a remote call, resulting in a large amount of unreliable communication. Therefore, you need to make coarse-grained methods into finer-grained communication.

Decentralized governance

One of the benefits of centralized governance is standardization on a single platform. Experience has shown that the benefits of this trend are narrowing, since not all problems are the same, and the solution is not omnipotent. We are more inclined to use the right tools to solve the right problems, and monolithic applications are somewhat more advantageous than multi-lingual environments, but they are also suitable for all situations.

By splitting the components in the monolithic framework into different services, we have more choices when building them. Do you want to use node. js to develop a report page? Do it. Use C + + to build components that are always demanding? Very good. Do you want to improve the read performance of your components by switching between different types of databases? We now have the technical means to achieve it.

Of course, you can make more choices, but that doesn't mean you can do this because your system uses this way to violate the decisions that you already have.

A team that uses microservices prefers different standards. Instead of writing these standards on paper, they like the idea of developing useful tools to solve similar problems that developers encounter. These tools often grow from implementation and are shared across a wide range of, of course, they sometimes, and not necessarily, will adopt open source mode. Now that the open source approach is becoming more common, git or GitHub becomes their de facto version control system.

Netfix is such an organization, it is a very good example. Sharing useful, and especially practical, code libraries inspires other developers to use similar approaches to solve similar problems, and, of course, retains the power to use different methods as needed. Shared libraries are more focused on such issues as data storage, in-process communications, and the automation we're discussing next.

In the MicroServices community, the overhead problem is particularly noteworthy. This is not to say that the community does not consider the value of service interactions. On the contrary, it is because of the discovery of its value. This allows them to find various ways to solve them. Design patterns such as tolearant reader and consumer-driven contracts are often used by microservices. These patterns solve the problem of the consumption of independent services during the interaction. Using Consumer-driven contracts adds to your confidence and enables a quick feedback mechanism. In fact, we know that a team in Australia is committed to using Consumer-drvien contracts to develop new services. They use simple engineering to help them define the interface of the service. These interfaces become part of the automation build before the code for the new service is written. The built-in service only needs to point out the scope of these interfaces, an elegant way to avoid the ' YAGNI ' dilemma in the new software. These technologies and tools are perfected during use, limiting the need for centralized management by reducing coupling between services.

Perhaps decentralized governance popularized the idea that Amazon "compiles it, ops it". The team is fully responsible for the software they develop and also includes 7 * 24 hours of operation. The full responsibility approach is uncommon, but we do find that more and more companies are being promoted in their teams. Netfix is another component that accepts this idea. Wake up to the alarm clock 3 o'clock in the morning every day because you are very concerned about the quality of the code written. This is the same Incredibles thing in traditional centralized governance.

Decentralized data management

There are many different manifestations of the decentralized management of data. The most abstract level, it means that the common concepts in different systems are different. The problem with this is that when large cross-system integration occurs, users will get different promotional information using different post-sales support. This situation is called and does not show the user all promotional means. Different grammars do have the same meaning or (worse) the same meaning.

This problem is common among applications, but it also exists within the application, especially when the application is split into different components. A very useful way to deal with this problem is the field-driven design for bounded context. DDD splits complex fields into different context boundaries and their relationships. Such a process is useful for both the overall architecture and the microservices framework, but there is a clear relationship between the services, which helps us to differentiate between the context boundaries and, as we talked about in the business function, forcibly split.

MicroServices also dictate decentralized data management when the conceptual model is determined to be decentralized. When monolithic applications persist data using a single logical database, enterprises typically choose to use a database within the scope of the application, which is also driven by the vendor's commercial rights model. MicroServices let each service manage its own database: whether it's a different instance of the same database, or a different database system. This method is called polyglot persistence. You can use this method in the overall architecture, but it is more common in the microservices architecture.

Figure 4:polyglot Persistence

Micro-service sound dispersion data incumbent means managing data updates. A common way to handle data updates is to use transactions to ensure that different resources modify the consistency of the database. This approach is typically used in the overall architecture.

A transaction is used because it can help deal with a sexual problem, but the consumption of time is severe, which poses a problem for cross-service operations. Distributed transactions are very difficult to implement, so the MicroServices architecture emphasizes the coordination of inter-service transactions, and a clear understanding of consistency can only be the final consistency and the processing of problems through compensation operations.

Choosing to handle inconsistencies is a new challenge for the development team, but it is also a common business practice model. Often business is allowed to be inconsistent to meet the demand for fast response, but it also uses some recovery processes to handle this error. This is a value when the business handles strong consistency consumption less than the consumption of processing errors.

Infrastructure automation

Infrastructure automation technology has grown dramatically over the past few years: cloud computing, especially AWS, has reduced the complexity of building, publishing, and operational microservices.

Many of the products or systems that use the microservices architecture, their teams have a rich set of holding deployments and the experience of their predecessor's continuous integration. Teams use this approach to build software that leads to a broader reliance on infrastructure automation technology. Describe the process of this build:

Figure 5: The Basic build process

Although this is not an introduction to automatic deployment, we would also like to introduce the main features of this article. We want our software to work so conveniently, so we need more automated testing. The software improvements that work in the process mean that we can automatically deploy to a variety of new environments.

The overall style of application is very happy to build, test, publish in various environments. It turns out that once you're going to invest in a whole-structure application of automated production lines, you'll find that releasing more apps seems a little less scary. Remember, one of the goals of CD (continuous deployment) is to make publishing uninteresting, so it's just as uninteresting whether it's one or three apps.

On the other side, we find that the teams that use microservices rely more on infrastructure automation. In contrast, in the overall architecture also microservices architecture, although the release of the scene is different, but the publishing work is not much of a boring difference.

Figure 6: The difference between a modular deployment

Design of fault tolerance

One result of using the service as a component is that the application needs to have a design that can tolerate the failure of the service. The task service may fail because the vendor is unreliable, and the client needs to optimize the response of this scenario as much as possible. This is a disadvantage compared to the overall architecture, as it brings additional complexity. This will allow the MicroServices team to think of the user's experience in the event of a service failure at all times. Netflix's Simian army can provide daily fault detection and recovery for each application's service and data center.

Automated testing in this product allows most operations teams to commute normally. This does not mean that the application of the overall architecture does not have such a sophisticated monitoring configuration, but it is not common in our experience.

Because the service can fail at any time, rapid fault detection, and even, automatic recovery of changes is very important. Micro-service applications put real-time monitoring in all phases of the application, detecting the architecture elements (number of requests received per second database) and business-related metrics (number of orders received in minutes). The monitoring system can provide an early fault alarm system for the development team to follow up and investigate.

This is important for the microservices framework, because microservices communicate with each other and can lead to emergency unexpected behavior. Many expert cars applaud the value of such emergencies, but the fact is that such emergencies are sometimes disastrous. Monitoring is critical, and it can quickly detect this kind of emergency behavior and let us fix it quickly.

The overall architecture, like microservices, is well-lit at the time of construction, and in fact, they are. They differ in that you need to be aware that services running between different processes are irrelevant. Libraries are transparent to the same process and therefore less important.

The MicroServices team expects to clearly monitor and document the configuration of each service, such as the use of dashboards to display up/down status, various operations related metrics. We also often encounter the status of circuit breakers (circuit breaker), current throughput, and latency details.

Design improvements

Micro-service practitioners, who often have a background in improving their design, break down services into further tools. These tools allow application developers to control changes in the needs of their applications without changing the speed. Change control does not mean the first reduction in change, but rather the use of appropriate means and tools to make it more frequent, at least, so that it becomes manageable.

However, when you try to split the software system into components, you will be faced with the problem of how to split it. So what is the principle of our decision to divide our application? The first factor is that components can be replaced and updated independently, which means that the key to our search is to imagine rewriting a component without affecting their previous collaborative relationships. In fact, many microservices teams have given it a further expectation that services should be scrapped rather than long-term.

Guardian website is a good example of this, it was initially designed and built into a holistic architecture, but it has been to the development of micro-services. The overall architecture is still at the heart of its web site, but they use microservices to add new features that use the overall architecture API. This method is easy to add to these temporary features, such as feature articles for sports News. A part of the site can be quickly integrated using a fast development language that can be removed once it becomes obsolete. We found a financial institution that added new marketing activities in a similar way, and withdrew it in a few weeks or months.

Substitution is a special case in modular development, which uses modules to respond to changes that need to be made. You want the change to be the same module that changes in the same cycle. Some small parts of the system that make changes should also be placed in different services so that they are more likely to die out. If you find that two services have been repeatedly changed, this is a signal to merge them.

Changing the component to a service adds an opportunity to refine the release plan. The task change of the overall architecture requires a complete build and release of the entire application. However, with microservices, you just need to publish the services you want to modify. This will simplify and accelerate your release cycle. The downside is that you need to worry about a change service release that might disrupt the user's experience. The traditional integration approach is to use versions to address these issues, but the microservices version is only the last means of notification. We need to tolerate vendor changes as much as possible in the design of our services to avoid the availability of multiple versions.

is micro-service the future?

Our main purpose in writing this article is to explain the main ideas and principles of microservices. But when it comes time to do this, we realize that the MicroServices architecture style is a very important idea: something that deserves serious consideration in enterprise applications. We recently used this style to build a few systems that recognize enthusiasts who also use and like this approach.

We know the pioneers who use this approach, including Amazon, Netflix, the Guardian, the UK government Digital Service, realestate.com.au, Forward and comparethemarket.com. The 2013-looking tour is filled with companies that are thinking of becoming a micro-service, including Travis CI. In addition, a large number of components are engaged in what we consider to be microservices, just not using the name of the microservices. (in general, they are labeled as SOA, although we think there are many different areas of SOA.) ）

Despite these positive experiences, we are not in a hurry to confirm that microservices are the future software architecture direction. So far, our experience has had an advantage over the overall style, but we are aware of the fact that we do not have enough time to prove our argument.

The architecture you use is usually the actual result of the years you have developed and used. We see that these projects are in a good team, with a strong desire for modularity, built with an overall architecture that has been declining in the last few years. Many people believe that this recession is unlikely to be related to microservices because the boundaries of services are clear and difficult to refine. However, when we have not seen enough systems running long enough, we cannot be sure that the microservices architecture is mature.

Of course, there are also reasons to expect that the microservices architecture is not mature enough. The success of any component effort depends on how the software is split into suitable components. It is very difficult to point out that the exact boundary of the component should be there. The improvement design should recognize the dilemma of the rights and interests of the boundary and the importance of easy reconstruction. But when your component is a service that is being remotely communicated, refactoring is much more difficult than the in-process library. Code migrations on service boundaries are difficult, and task interface changes require the collaboration of participants, the level of backward compatibility needs to be increased, and testing is more complex.

Another problem is that if the components are not clearly divided, the complexity of your work will move from the inside of the component to the relationship between the components. To do this not only revolves around complexity, it also has to face unclear and more difficult to control the place. It's easy to think that it's easier to find something in a small, simple component than in a messy service that doesn't have a relationship.

Finally, team skills are also important factors. New technologies tend to be used by teams with more skills to master. But the skills used in a multi-skilled team are not required in less-skilled teams. We found that a large number of less-skilled teams built a chaotic integration framework, but it was time to prove what would happen with microservices in this situation. A bad team usually develops bad systems: it's hard to say whether MicroServices can help them in this situation or destroy them.

A rational controversy is that we have heard that you should not start with the microservices architecture. Preferably from the overall framework development, do modular development, and then when the overall structure of the problem is the modular split into services. (Although this advice is not a good idea, because a good in-process interface is not a good service interface.) ）

So we hold this cautious optimism. So far, we have not enough knowledge about whether the micro-structure can be widely promoted. We can't say for sure what we want to end, but the challenge of software development is that you can only decide what you're dealing with in incomplete information.

Other How big is the microservices system?

Although the word "microservices" is becoming more and more popular in architectural style, its name is very much concerned about its service size and its controversy over the composition of "micro". In our conversations with micro-service practitioners, we discovered the size of the service. The largest team to be reported follows the Amazon tow Pizaa team concept (for example, a team eats two pizzas.) ), which means no more than number 20th (a dozen) people. We found that the smallest configuration was a half dozen teams supporting a dozen of services.

This has also led to the consideration of the scale of a service a dozen people to a service a person's team to make a micro-service label. At the moment we think that they are the same, but as we delve into this style, there is the possibility that we will change our minds.

MicroServices and SOA

At the moment when we talk about microservices, it is often asked whether this is a service-oriented architecture (SOA) We discussed 20 years ago. This is a good idea because microservices are similar to some of the advantages that SOA advocates. The problem, though, is that SOA means too many different things, so often when we talk about the so-called "SOA," it differs from the style we're talking about, because it usually refers to an ESB in a holistic style application.

In addition, we found that the service-oriented style was so clumsy: from trying to hide complexity with an ESB, to a failure that took years to realize that the cost of $ hundreds of was not generating a mission value, to centralize governance mode to suppress change. And these problems are often difficult to find.

To be sure, many of the technologies used in the MicroServices community are developed from the integrated service experience of large organizations. Tolerant reader mode is an example of this. Thanks to the development of the Internet, this method of using simple protocols allows it to be conveyed from these experiences. It's an anti-pattern from an already complex set of centralized standards, and frankly, it's amazing. (Whenever you need to use a service to manage all of your services, you know it's a hassle.) ）

This common behavior of SOA allows the advocates of microservices to reject the labeling of SOA, even though some believe that microservices are evolving from SOA, and perhaps service-oriented is right. In any case, the fact that SOA conveys so much meaning gives a team a clear sense of the value of this architectural style.

Multi-lingual, multi-choice

The JVM is a platform, and its growth is the biggest example of running multiple languages in a platform. For the past 20 years, it has often been used as a shell for higher-level languages to achieve a higher level of abstraction. For example, study its internal structure, and write more efficient code in low-level languages. However, many of the overall styles do not require this level of performance optimization or abstraction at the grammatical and high levels, which is common (disappointing). In addition, the overall architecture usually implies the use of a single language, which also limits the number of technologies used.

Practice standards and mandatory standards

It's a little awkward, and the microservices team tends to avoid the stiff enforcement standards that are usually customized by the Enterprise Architecture team, but they are happy to even promote these open standards, such as HTTP, ATOM, and other micro specifications.

The key differences are how these standards are developed and how they are promoted. Standards are managed by some components, such as IETF certification standards, and only when they have several implementations on the internet, often originating from successful applications of open source projects.

These standards separate themselves from the kind of vendor standards that typically have no coding experience or influence in the enterprise.

Make it easier to do things

On the one hand, we find that in the continuous release, deployment of more and more use of automation, is a lot of useful tools developed to help developers and operators of the results. Tools for packaging, code management, supporting service tools, or adding records for standard monitoring are now commonplace. Perhaps the best in the network is Netflix's open source tool, but other tools, including Dropwizard, are widely used.

Circuit breakers (circuit breaker) and existing code in the product

The circuit breaker (circuit breaker) appears in the Realease it! Book, with patterns such as bulkhead and timeout. Implemented, these patterns are quite important for building communication applications. Netflix's blog has done a lot of work explaining their applications.

Synchronization is harmful

At the time of the task, you will encounter the product effect of downtime by using synchronous methods in the call between services. Simply put, your system outage time is the product of the downtime of your system's individual components. The choice you face is to use async or manage downtime. In www.guardian.co.uk, they use a simple rule in the new platform to implement it: each time a user requests a synchronous call in Netflix, the platform API they redesign will build it into an asynchronous API to execute.

http://blog.csdn.net/wurenhai/article/details/37659335

Micro-service--martin Flower "translation"