In software engineering, a microservice architecture is a variant of the service-oriented architecture structural style. It is an architectural pattern that arranges an application as a collection of loosely coupled, fine-grained services, communicating through lightweight protocols. One of its goals is that teams can develop and deploy their services independently of others. This is achieved by the reduction of several dependencies in the code base, allowing developers to evolve their services with limited restrictions from users, and for additional complexity to be hidden from users.^[1] As a consequence, organizations are able to develop software with fast growth and size, as well as use off-the-shelf services more easily. Communication requirements are reduced. These benefits come at a cost to maintaining the decoupling. Interfaces need to be designed carefully and treated as a public API. One technique that is used is having multiple interfaces on the same service, or multiple versions of the same service, so as to not disrupt existing users of the code.

Some of this article's listed sources may not be reliable. (October 2018)

There is no single definition for microservices. A consensus view has evolved over time in the industry. Some of the defining characteristics that are frequently cited include:

• Services in a microservice architecture are often processes that communicate over a network to fulfill a goal using technology-agnostic protocols such as HTTP.^[2][3][4]
• Services are organized around business capabilities.^[5]
• Services can be implemented using different programming languages, databases, hardware and software environments, depending on what fits best.^[6]
• Services are small in size, messaging-enabled, bounded by contexts, autonomously developed, independently deployable,^[7][6] decentralized and built and released with automated processes.^[7]

A microservice is not a layer within a monolithic application (for example, the web controller or the backend-for-frontend).^[8] Rather, it is a self-contained piece of business functionality with clear interfaces, and may, through its own internal components, implement a layered architecture. From a strategic perspective, microservice architecture essentially follows the Unix philosophy of "Do one thing and do it well".^[9] Martin Fowler describes a microservices-based architecture as having the following properties:^[2]

• Lends itself to a continuous delivery software development process.^[10] A change to a small part of the application only requires rebuilding and redeploying only one or a small number of services.^[11]
• Adheres to principles such as fine-grained interfaces (to independently deployable services), business-driven development (e.g. domain-driven design).^[12]

It is common for microservices architectures to be adopted for cloud-native applications, serverless computing, and applications using lightweight container deployment. According to Fowler, because of the large number (when compared to monolithic application implementations) of services, decentralized continuous delivery and DevOps with holistic service monitoring are necessary to effectively develop, maintain, and operate such applications.^[13] A consequence of (and rationale for) following this approach is that the individual microservices can be individually scaled. In the monolithic approach, an application supporting three functions would have to be scaled in its entirety even if only one of these functions had a resource constraint.^[14] With microservices, only the microservice supporting the function with resource constraints needs to be scaled out, thus providing resource and cost optimization benefits.^[15]

There are numerous claims as to the origin of the term microservices. As early as 2005, Peter Rodgers introduced the term "Micro-Web-Services" during a presentation at the Web Services Edge conference. Against conventional thinking and at the height of the SOAP service-oriented architecture (SOA) hype curve he argued for "REST-services" and on slide #4 of the conference presentation, he discusses "Software components are Micro-Web-Services".^[16] He goes on to say "Micro-Services are composed using Unix-like pipelines (the Web meets Unix = true loose-coupling). Services can call services (+multiple language run-times). Complex service assemblies are abstracted behind simple URI interfaces. Any service, at any granularity, can be exposed." He described how a well-designed microservices platform "applies the underlying architectural principles of the Web and REST services together with Unix-like scheduling and pipelines to provide radical flexibility and improved simplicity in service-oriented architectures.^[16]

Rodgers' work originated in 1999 with the Dexter research project at Hewlett Packard Labs, whose aim was to make code less brittle and to make large-scale, complex software systems robust to change.^[17] Ultimately this path of research led to the development of resource-oriented computing (ROC), a generalized computation abstraction in which REST is a special subset.

In 2005 Alistair Cockburn wrote about hexagonal architecture which is a software design pattern that is used along with the microservices. This pattern makes the design of the microservice possible since it isolates in layers the business logic from the auxiliary services needed in order to deploy and run the microservice completely independent from others.

A workshop of software architects held near Venice in May 2011 used the term "microservice" to describe what the participants saw as a common architectural style that many of them had been recently exploring.^[18] In May 2012, the same group decided on "microservices" as the most appropriate name. James Lewis presented some of those ideas as a case study in March 2012 at 33rd Degree in Kraków in Microservices - Java, the Unix Way,^[19] as did Fred George^[20] about the same time. Adrian Cockcroft, former director for the Cloud Systems at Netflix,^[21] described this approach as "fine-grained SOA", pioneered the style at web-scale, as did many of the others mentioned in this article - Joe Walnes, Dan North, Evan Bottcher, and Graham Tackley.^[22]

Microservices is a specialization of an implementation approach for service-oriented architectures used to build flexible, independently deployable software systems.^[5] The microservices approach is the first realisation of SOA that followed the introduction of DevOps and is becoming more popular for building continuously deployed systems.^[23]

In February 2020, the Cloud Microservices Market Research Report predicted that the global microservice architecture market size will increase at a CAGR of 21.37% from 2019 to 2026 and reach $3.1 billion by 2026.^[24]

A key step in defining a microservice architecture is figuring out how big an individual microservice has to be. There is no consensus or litmus test for this, as the right answer depends on the business and organizational context.^[25] For instance, Amazon uses a service-oriented architecture where service often maps 1:1 with a team of 3 to 10 engineers.^[26] Generally, the terminology goes as such: services that are dedicated to a single task, such as calling a particular backend system or making a particular type of calculation, are called atomic services. Similarly, services that call such atomic services in order to consolidate an output, are called composite services.

It is considered bad practice to make the service too small, as then the runtime overhead and the operational complexity can overwhelm the benefits of the approach. When things get too fine-grained, alternative approaches must be considered - such as packaging the function as a library, moving the function into other microservices.^[5]

If domain-driven design is being employed in modeling the domain for which the system is being built, then a microservice could be as small as an aggregate or as large as a bounded Context.^[27]

In the granularity of microservices discussion, there is a spectrum, in one end there are the Anaemic Services, which do not have a large number of responsibilities, and on the other end, the Modular Monolith, which are large modules of a system.

The benefit of decomposing an application into different smaller services are numerous:

• Modularity: This makes the application easier to understand, develop, test, and become more resilient to architecture erosion.^[6] This benefit is often argued in comparison to the complexity of monolithic architectures.^[28]

• Scalability: Since microservices are implemented and deployed independently of each other, i.e. they run within independent processes, they can be monitored and scaled independently.^[29]

• Integration of heterogeneous and legacy systems: microservices is considered a viable means for modernizing existing monolithic software application.^[30][31] There are experience reports of several companies who have successfully replaced (parts of) their existing software with microservices or are in the process of doing so.^[32] The process for software modernization of legacy applications is done using an incremental approach.^[33]
• Distributed development: it parallelizes development by enabling small autonomous teams to develop, deploy and scale their respective services independently.^[34] It also allows the architecture of an individual service to emerge through continuous refactoring.^[35] Microservice-based architectures facilitate continuous integration, continuous delivery and deployment.^[36]

The microservices approach is subject to criticism for a number of issues:

• Services form information barriers.^[37]
• Inter-service calls over a network have a higher cost in terms of network latency and message processing time than in-process calls within a monolithic service process.^[2]
• Testing and deployment are more complicated.^[38][39]
• Moving responsibilities between services is more difficult.^[6] It may involve communication between different teams, rewriting the functionality in another language or fitting it into a different infrastructure.^[2] However, microservices can be deployed independently from the rest of the application, while teams working on monoliths need to synchronize to deploy together.^[33]
• Viewing the size of services as the primary structuring mechanism can lead to too many services when the alternative of internal modularization may lead to a simpler design.^[40] This requires understanding the overall architecture of the applications and interdependencies between components.^[41]
• Two-phased commits are regarded as an anti-pattern in microservices-based architectures, resulting in a tighter coupling of all the participants within the transaction. However, the lack of this technology causes awkward dances which have to be implemented by all the transaction participants in order to maintain data consistency.^[42]
• Development and support of many services are more challenging if they are built with different tools and technologies - this is especially a problem if engineers move between projects frequently.^[43]
• The protocol typically used with microservices (HTTP) was designed for public-facing services, and as such is unsuitable for working internal microservices that often must be impeccably reliable.^[44]
• While not specific to microservices, the decomposition methodology often uses functional decomposition, which does not handle changes in the requirements while still adding the complexity of services.^[44]
• The very concept of microservice is misleading since there are only services. There is no sound definition of when a service starts or stops being a microservice.^[44]
• Data aggregation. In order to have a full view of a working system, it is required to extract data sets from the microservices repositories and aggregate them into a single schema. For example, to be able to create operational reports that are not possible using a single microservice repository.

Computer microservices can be implemented in different programming languages and might use different infrastructures. Therefore, the most important technology choices are the way microservices communicate with each other (synchronous, asynchronous, UI integration) and the protocols used for the communication (RESTful HTTP, messaging, GraphQL ...). In a traditional system, most technology choices like the programming language impact the whole system. Therefore, the approach to choosing technologies is quite different.^[49]

The Eclipse Foundation has published a specification for developing microservices, Eclipse MicroProfile.^[50][51]