A recent Vanson Bourne survey of 200 senior IT leaders found that 84% of enterprises have already embraced the benefits of microservices. The survey participants also agreed that a failure to adopt microservices would make enterprises less competitive in the future.
The question is, why are microservices so helpful to modern enterprises? What benefits do corporations receive from using this architectural style?
In this article, we provide an in-depth exploration of seven key benefits of microservices. But first, we’ll provide a brief definition of microservices to bring newcomers up to speed on this technology.
Browse the microservices benefits that interest you:
- Improved Scalability
- Better Fault Isolation and More Resilient Applications
- Programming Language and Technology Agnostic
- Better Data security and Compliance
- Faster Time to Market and “Future-Proofing”
- Greater Business Agility and Support for DevOps
- Support for Two-Pizza Development Teams
What Are the Benefits of Microservices?
A microservices application architecture involves breaking a monolithic application into its component functions or services. After identifying the individual services, developers refactor the monolith so that each service runs autonomously as a separate “microservice.” Then, they loosely connect these microservices via APIs to form the larger microservices-based application.
The resulting microservices-based application offers a pluggable architectural style. This style enables fast and cost-efficient upgrades. This makes it easier and less expensive to scale one part of the application. You can do this without affecting the rest of the application.
Developers usually run each microservice in a container on a cloud-based server such as Amazon AWS. Then they use container orchestration tools like Kubernetes to efficiently allocate processing power and other resources to the containers as required.
For a more detailed overview of microservices, check out our guide, “What Are Microservices?”
The Benefits of Microservices
Below we’ll explore seven key benefits of microservices with illustrations and examples:
1. Improved Scalability
The capacity of each microservice to run autonomously makes it relatively easy to add, remove, update, and scale individual microservices. This can be done without disrupting the other microservices that comprise the application. When demand increases, you only need to upgrade or divert more resources to the microservice affected by the increasing demands.
When appropriately calibrated, a container orchestration tool can scale individual microservices automatically by allocating more processing power – or spinning up new instances of microservices – as required. By only scaling the services that need it, for as long as they need it, enterprises can save a lot of money on the cost of cloud server resources.
Netflix is an excellent example of using microservices to overcome scaling challenges. In late 2008, Netflix experienced a three-day service failure caused by increasing demands on its servers. After struggling to scale to these demands, Netflix decided to refactor its monolithic application into a horizontally-scalable, distributed system of microservices running on Amazon AWS cloud servers.
As Netflix states on their blog:
We migrated from a monolithic app to hundreds of microservices, and denormalized our data model, using NoSQL databases. Budget approvals, centralized release coordination, and multi-week hardware provisioning cycles made way to continuous delivery, engineering teams making independent decisions using self-service tools in a loosely coupled DevOps environment, helping accelerate innovation…
According to Netflix, the transition to cloud-based microservices took a lot of time and effort, but it put the company “in a much better position to continue to grow and become a global TV network.”
Here’s a map of the Netflix microservices architecture:
2. Better Fault Isolation for More Resilient Applications
With a microservices architecture, the failure of one service is less likely to negatively impact other parts of the application because each microservice runs autonomously from the others. Nevertheless, large distributed microservices architectures tend to have many dependencies, so developers need to protect the application from a dependency failure related shut down. According to InfoQ, “on a high volume website, a single back-end dependency becoming latent can cause all application resources to become saturated in a matter of seconds (see image).”
Fortunately, the benefits of microservices architecture allows developers to prevent cascading failures with features like circuit breaker, which averts server resource depletion if a calling service has to remain on hold for a failed service that never responds. Also, Floyd May recommends avoiding Remote Procedure Calls (RPCs) between microservices to prevent cascading failures:
Avoid RPCs between microservices if possible – they cause cascading failures. If you refactor an operation out into a separate service, redesign the containing operation to be fully asynchronous. Leverage the message bus to insulate services from one another so that temporary failures, redeploys, or downtime in one service don’t guarantee failures in another.
Finally, you can build fault-tolerant microservices using Hystrix, an open-source solution that Netflix created stop cascading failure and bolster the resilience of its infrastructure. According to Netflix, “Hystrix is a latency and fault tolerance library designed to isolate points of access to remote systems, services, and 3rd party libraries, stop cascading failure and enable resilience in complex distributed systems where failure is inevitable.”
3. Programming Language and Technology Agnostic
When creating a microservices-based application, developers can connect microservices programmed in any language. They can also connect microservices running on any platform. This offers more flexibility to use the programming languages and technologies that best fit the needs of the project and the skillsets of your team.
Lianping Chen expands on this when writing about the microservices journey of Paddy Power, an online gambling company:
Teams can choose different technologies for implementing their services. I found that this is particularly useful when adopting a new technology. An example was the introduction of the Scala language, which is a better option for developing low latency and high throughput applications. A team was able to use Scala in their own service without impacting other services, which used C++. Such a change would not be technically easy if it were part of a monolithic application.
Here’s an image of Paddy Power’s microservices architecture:
Lastly, the users of a cloud-based microservices application can access the application from any internet-connected device – regardless of whether it’s a PC, Mac, Android, or iOS platform.
4. Better Data Security and Compliance
Each of the benefits of microservices contains and protects the sensitive data inside it. Nevertheless, when developers establish data connections between the microservices, information security becomes a concern. Fortunately, most developers use secure APIs to connect microservices. A secure API safeguards the data it processes by making sure it’s only accessible to specifically authorized applications, users, and servers.
If your microservices are managing sensitive health, financial, or other kinds of confidential information, a secure API gives developers complete control over what data is accessible to the larger application and those who are using it. This makes it easier to achieve compliance under HIPAA, GDPR, and other data security standards.
An iPaaS (Integration Platform as a Service) like DreamFactory can assist with the process of developing secure APIs to support a microservices architecture. DreamFactory’s automatic API generation tools empower you to build and publish secure APIs in minutes.
5. Faster Time to Market and “Future-Proofing”
The pluggability of a microservices application architecture allows for easier and faster application development and upgrades. Developers can quickly build or change a microservice, then plug it into the architecture with less risk of coding conflicts and service outages. Moreover, due to the independence of each microservice, teams don’t have to worry about coding conflicts, and they don’t have to wait for slower-moving projects before launching their part of the application.
Microservices also support the CI/CD/CD (Continuous Integration, Continuous Delivery, Continuous Deployment) development philosophy. This means that you quickly deploy the core microservices of an application – as a minimum viable product (MVP) – and continuously update the product over time as you complete additional microservices. It also means that you can respond to security threats and add new technologies as they appear. The result for the user is a “future proof” product that’s constantly evolving with the times.
6. Greater Business Agility and Support for DevOps
Experimenting with new features – that may or may not be successful – does not pose as much of a business risk with a microservices-based architecture. Also, because you easily try out new features and roll back the changes if it doesn’t work out, enterprises have greater agility to respond to new business demands and user feedback without the threat of technology or vendor lock-in.
According to the Spring Developer Advocate at Pivotal, Josh Long, the most important advantage of microservices “would be agility, the ability to iterate on a small, focused piece of functionality quickly, and to see results.”
Microservices also support the DevOps mindset. Since businesses can rapidly develop and deploy new features, users get to see their feedback in action in weeks not months or years. This promotes collaboration among users, developers, and engineers – which boosts user retention and satisfaction.
7. Support for Two-Pizza Development Teams
Amazon, the first pioneer of microservices, used this architectural style to support the “two-pizza development team rule.” Teams are kept small enough to be fed by two pizzas. Amazon claims that the two-pizza rule:
- Improves work efficiency
- Makes teams easier to manage
- Achieves goals faster
- Results in greater focus
- Produces higher quality products
By assigning ownership of each microservice to a small team, the individual teams can work more closely, stay on the same page, and be more focused and accountable for their work. Christian Posta offers a great explanation of why the two-pizza rule is so effective:
To create and sustain autonomous, creative, innovative teams, you don’t want “more communication” you want “effective communication.” This is easier said than done, but it starts by having smaller groups of people work together. They get to know each other better, they form relationships, trust, and motivation.
DreamFactory: Automatically Build and Publish Rest APIs to Connect Your Microservices
Now that you understand the key benefits of a microservices application architecture, you might be considering a microservices adoption strategy for your enterprise. If that’s the case, you’ll want an advanced iPaaS to integrate the microservices that comprise your application.
The DreamFactory iPaaS features a user-friendly, visual interface for integrating the microservices that comprise microservices-based applications. With DreamFactory’s automatic REST API generation tools, you can transform the time-consuming and labor-intensive task of building and publishing APIs a point-and-click process that takes only minutes. Try a free hosted trial of DreamFactory now!
Microservices Examples: How Amazon, Netflix, Uber, and Etsy Broke Their Monoliths and Scaled to Unprecedented Heights with Microservices, What Are Containerized Microservices, ESB vs Microservices: Understanding Key Differences, Designing Web-Scale Workloads with Microservices, Designing Web-Scale Workloads with Microservices, Microservices Webinar Recap, API Trends: Monolithic vs Microservices