14
Jul
2016

Solving architectural bottleneck with a Microservices

Since last couple of years, software industry has been embracing a term called “Microservices”. Technical experts have been trying to utilize it according to their own specific requirements by understanding this new concept. The idea of Microservices is that a big application is broken into smaller and composable pieces. Thereafter, each piece is developed separately and later on combined together that results in a single application. This has made the entire application development process easier for the developer than the traditional approach of developing a big piece.

SOA or Microservices?

After reading about the Microservices, few even considered it similar to the SOA –Service Oriented Architecture. The idea behind both is same, separating applications into smaller part. However, they both do not share the same features. As the SOA follows an imperative programming style whereas Microservices use responsive-actor programming style. SOA has more dependent Enterprise Service Bus (ESB), on the other hand, Microservices use faster messaging mechanisms. Microservices use micro-SQL databases or NoSQL database, whereas SOA models use an outsized relational database. Learn more about difference between web services and microservices.

What Microservices architecture really means?

As there is no standard model to follow Microservices architecture, however, there are few of its characteristics that make it different from SOA:

Microservices Architecture

Componentization

The foremost point or say a benefit of using the Microservices architecture is that the big application can be broken down into smaller multiple components. This means developers are assigned to each of these components to work independently. Therefore, each component can be deployed, pulled off or redeployed without affecting the application’s reliability. On getting a request to change do not require redeploying the entire applications.

More Organized

Unlike the traditional approach of SOA that focus on involving different teams for databases, service side logic or technology layers, the Microservices architecture works on focusing the cross-functional teams. This means, whenever any new changes arrive, then the developer of the particular component should require to work on them and not necessarily wait for the change as a whole or for budget approval.

Here the approach is to distribute each component subjective to the business capability. In this, software is strongly implemented for the specific business area which includes persistence storage, user interface and external collaborations. Cross-functional teams are responsible for working on the individual services formed upon splitting a product by communicating via. a message bus.

Product Development and not Project

Most often, the term Project is used throughout the application development phase. However, the end result is a piece of software. After completing the development, the product is handed to the maintenance team. Contrary to this, in a Microservices approach, the software development team fully owns the product for the full time. This means, a developer gains accessibility of their software and knows how it is behaving daily that initiates contacting their users.

With such approach, there is an increase in communication with the users. Hence, the user gets ongoing support from the developers that also improves the business capabilities.

Smart endpoints and dumb pipes

During the development of the communication structures between the different processes, it has been observed that the products and approaches put intelligence in their communication mechanism. Taking an example of Enterprise Service Buses (ESBs), where they include the facilities for message routing, choreography, and business rules application.

Next on coming to Microservices, it has been found to have smart endpoints and dumb pipes. Here, they act like a traditional UNIX system like receiving requests, processing them and then generating a process. The applications developed by following the Microservices approach targets to be decoupled and cohesive. Most commonly used protocols are HTTP request response with resource APIs and lightweight messaging.

Decentralized governance and data management

The Microservices follows various technologies and platforms, therefore, the decentralized governance is followed. Instead of following defined standard, they prefer of producing the tools that will be helpful for those developers who are facing the same problems. The tools are developed by following the approach of implementation and sharing with the group.

A live example can be seen is Netflix, where they have asked the developers to use the existing code libraries, whereas also utilize the other solutions available. Microservices also use decentralized data management where they manage their unique database, unlike monolithic systems which use a single database for their specific applications.

Handle failure

Now when services are used as components, then in Microservices, applications are designed in a way to handle the failure. The failure can be due to any of the reason, hence, the client has to respond to its neighboring services gracefully. This adds an advantage to the Microservices to deal with all types of complex failures which is difficult to handle in the monolithic systems architecture.

As the service can fail anytime, but it always requires immediate attention in identifying and rectify the errors quickly. Microservices use real-time monitoring of the application to detect the failure and quickly restore the application.

Evolutionary design

Microservices have got an evolutionary design which allows the developers to control the changes without affecting its speed. The true definition of the change reduction is using the right approach or tool to do the job without affecting the speed and control the changes. Many Microservices groups followed the approach to disposing the services instead of running them for a long term.

A very good example is The Guardian website which is purely based on monoliths API, however, follows Microservices when wanted to add new features. Such approach is followed when required to perform an action for a desired period of time and then discarded after not required.

Microservices architecture style is an important idea which has been considered by several Enterprise Application. Few popular names are Amazon, The Guardian, Netflix, UK Government Digital Service and much more.



Comments

Leave a Reply

Your email address will not be published. Required fields are marked *