Microservices Architecture: Scalability, DevOps, Agile development
Microservices Architecture: Scalability, DevOps, Agile development
June 02, 2017 | Atul Saini
Category: Application Architecture, Microservices
With the emergence of the digital economy, there's a big buzz around Cloud, Big Data and the API economy. In all the noise, we sometimes still forget that to deploy systems across these domains, one still has to create services and compose multiple services into working distributed applications. Microservices have emerged as the latest trend in development based on these increasingly demanding requirements, based on the perceived failure of Enterprise-wide SOA ("Service Oriented Architecture") projects.
SOA was all the hype since the early 2000's but disappointed for many reasons in spite of many successful projects. SOA was (and still is in many quarters) perceived as being too complex: developers spent months just deciding on the number and nature of interfaces of a given service. Often, services were too big and had hundreds of interfaces, making them difficult to use; at the other extreme, some developers designed services that had just a few lines of code, making them too small. It was difficult for users to decide on and choose the granularity of a service for the most part. Microservices solve these and several other problems with classic SOA.
Before getting into details, it is important to define the modern meaning of the term "Application". Applications are now "Collections of Components/Services, strung together via connections in the form of asynchronous message-flows and/or synchronous request/rely calls". The participating Services may be distributed across different machines and different clouds (on-premise, hybrid and public).
The Emergence of Microservices
Microservices emerged from the need to 'make SOA work', to make SOA productive, fast and efficient and from a need to deploy and modify systems quickly. In short, Microservices support agile development. Key concepts that have emerged over the past ten years are:
(a) Coarse-grained, process-centric Components:
Each Microservice typically runs in a separate process as distinct from a thread within a larger process. This ensures the component is neither too small nor too large. There isn't any hard and fast rule here, except to ensure that Microservices are not 'thread-level bits of code'.
(b) Data-driven interfaces
With a few inputs and outputs. In practice, most productive Microservices typically have only a few inputs and outputs (often less than 4 each). The complexity of the SOA world in specifying tens or even hundreds of interfaces has disappeared. Importantly, inputs and outputs are also 'coarse grained' - typically XML or JSON documents, or data in any other format decided by the developer. Communication between Microservices is document-centric - an important feature of Microservices architecture. For those experienced enough to appreciate the point, one can think of a Microservice as a "Unix pipe" with inputs and outputs.
(c) No external dependencies:
The implementation of each Microservice contains all the necessary dependencies, such as libraries, database-access facilities, operating-system specific files, etc. This ensures that each Microservice can be deployed anywhere over a network without depending on external resource libraries being linked in. The sole communication of a Microservice with the external world is via its input and output 'ports'.
(d) Focused functionality:
A Microservice is typically organized around a single, focused capability: e.g. access/update a Database, Cache input data, update a Bank account, Notify patients, etc. The lesson from "complex SOA" is that the Services should not become too large, hence the term "Microservices"
(e) Independent interfaces:
Each Microservice typically has a GUI Associated with itself, for end-user interaction and configuration. There is no relationship between the GUIs of different Microservices - they can all be arbitrarily different. Each Microservice is essentially a 'product' in its own right in that it has defined inputs and outputs and defined, non-trivial functionality.
Benefits of Microservices and Microservices integration
In Microservices architecture, Applications are composed by connecting instances of Microservices via message-queues (choreography) or via request/reply REST calls (orchestration). Compared to classical monolithic application design, this approach offers many benefits for development, extensibility, scalability and integration.
Easy application scalability:
Since an application is composed of multiple micro services which share no external dependencies, scaling a particular micro service instance in the flow is greatly simplified: if a particular microservice in a flow becomes a bottleneck due to slow execution, that Microservice can be run on more powerful hardware for increased performance if required, or one can run multiple instances of the Microservice on different machines to process data elements in parallel.
Contrast the easy Microservices scalability with monolithic systems, where scaling is nontrivial; if a module has a slow internal piece of code, there is no way to make that individual piece of code run faster. To scale a monolithic system, one has to run a copy of the complete system on a different machine and even doing that does not resolve the bottleneck of a slow internal-step within the monolith.
It should be noted that integration platforms based on synchronous, process-centric technology such as BPEL, BPMN, and equivalents also suffer from this scalability problem. For instance, if a single step within a BPEL process is slow, there's no way to scale that independent step in isolation. All steps within a process-flow need to be executed on the same machine by design, resulting in significant hardware and software costs to run replicated systems for limited scalability.
Simplified Application Updates:
Since any given Microservice in the Application can be upgraded/replaced (even at runtime, provided the runtime system provides the required support) without affecting the other 'parts' (i.e. Microservices) in the application, one can update a Microservices-based application in parts. This greatly aids agile development and continuous delivery.
Since each Microservice is an independent 'product' (since it has no external implementation dependencies), it can be developed in any programming language; a single Microservices Application may thus include one or more Microservices developed in Java, C, C++, C#, Python and other languages supported by the Microservices platform
since each Microservice runs in its own process and shares no dependencies with others, it can be monitored, metered and managed individually. One can thus examine the status, input, outputs and data flows through any Microservice instances in an application without affecting either the other Microservices or the running system.
Decentralized Data Management:
In contrast to the classical three-tier development model which mandates a central data repository, thereby restricting the service-developer, each Microservice can store data as it pleases: a given Microservice can use SQL, a second MongoDB, a third a Mainframe database, etc. Just as there are no implementation-dependencies between Microservices, there are also no "database use" dependencies or even guidelines. The developer is thus free to make choices that fit the design of the particular Microservice at hand.
Automated Deployment and Infrastructure Automation:
Implementation independence allows assemblies of Microservices can be 'moved' from one deployment environment to another (for example, Development -> QA -> Stating -> Production), based just on profile settings. This 'one click' move between environments greatly aids Dev-ops and agile development
Each of these topics can and likely will be the subject of a separate blog post. Until then, enjoy your development!