Microservices architecture has been around since the turn of the century, but it has only recently gained traction. Change, like many paradigm shifts, necessitates an impetus. Why should you use microservices?
This post will provide an overview of key microservices benefits that have contributed to their popularity, as well as highlight a few situations where they are not appropriate.
What exactly is a microservice? Simply put, a service is some code that does work. The term "micro" is intended to imply a small size. The concept of a microservice's small size is central to the design. When I first started working with microservices, I was unsure of "how small?" I realized I needed to understand the structure of a microservices architecture, how it should be implemented, and how it was intended to be used. I hope that sharing what I've learned will help you on your microservices journey.
Characteristics of Microservices
The characteristics listed below describe the fundamental building blocks of a microservices architecture that are required to meet the design goals and reap the benefits. These will be used throughout the post.
Each microservice should be as follows:
- Deployable independently - for example, the front-end service can be deployed independently of the authentication service.
- Highly visible - by logging, monitoring, tracing, and other means, one can determine what the service is doing.
- Loosely coupled - the service can do its job without being overly reliant on how other services are defined or implemented.
- Decentralized - spread across multiple "systems," potentially across multiple geographies
- Highly testable - designed from the start to be tested using automated test frameworks with high coverage rates.
- Highly maintainable - well-structured, well-commented, simple to understand, simple to change, simple and quick to build, and so on (small size helps with all of this)
- Fungible - easily replaced or reimplemented as needs arise
- Concentrated and specialized, similar to the Unix philosophy of "do one thing well."
- Contractual - characterized by regimented, well-defined interfaces and planned life cycles
Monoliths vs. Microservices
Monolithic architecture has been around for a long time and has proven to be effective. Why add another architecture? Let's look at the distinctions between microservices and monolithic architectures.
A general rule of thumb is that a microservices-based application has at least an order of magnitude more moving parts than a monolithic application. Furthermore, each microservice typically runs in a separate process, is potentially distributed across multiple systems, and is not always dedicated to a specific application. Finally, to perform work, each microservice will communicate with other microservices, either directly via REST API, via a message bus, or via a variety of other protocols, depending on implementation.
In contrast to microservices, a monolithic architecture-based application is made up of fewer and larger parts that may or may not run as a single process (with no or very little process-to-process communication). A monolithic application is typically described as a discrete unit rather than the components that comprise it, with those components dedicated to that application. We use desktop and mobile applications on a daily basis.
One architecture does not fit all situations, and this post will assist you in determining whether the benefits of a microservices architecture are appropriate for your requirements.
7 Advantages of Microservices
Let us return to the characteristics mentioned at the start of this post. Why were these the microservices architecture design goals? Why are these qualities required?
The public cloud forever altered software. Every couple of years, delivering software on a disc became obsolete. Why bother installing software on your computer when you can rent it from the cloud? Software as a Service (SaaS) was born, but running a 24x7 cloud-based service introduces a whole new set of considerations in stark contrast to delivering a product on disc on a regular basis.
Because of economies of scale, many customers are expected to use the cloud-based service at the same time, all the time, all over the world. Customers who use the service will not tolerate downtime, so the service must scale to meet demand. Furthermore, whether it is to meet customer needs or to provide functionality ahead of a competitor, delivering features and fixes quickly is critical to success. Teams can achieve these goals by ensuring that their microservice is container-ready and following these microservice best practices.
This section will go over seven important microservices benefits and how the characteristics described at the beginning of the post enable them.
- Asymmetric Service Scaling
- Zero Downtime
- Intelligent Deployment
- Innovation Through Polyglot Programming
- Refactoring, Rewriting, and Decomposing
- Separation of Logic and Responsibilities
- Error Handling and Resiliency Design Patterns
1. Service Scaling Asymmetry
When a company deploys software to their own intranet, the maximum number of concurrent users is known. The software designed for that use case frequently has similar scalability upper bounds. A cloud-based service, on the other hand, must scale to many users from many different companies using the software at the same time, potentially orders of magnitude more users than a single intranet-based deployment.
One of the many advantages of microservices is that they are well-suited for massive scalability because each microservice can scale independently. In order to meet demand, the service must be "independently deployable" and "decentralized." A service that is "highly observable" provides metrics that can be used to drive scaling operations.
Furthermore, as the services scale in and out based on demand, the underlying host resources can also scale in and out, allowing those resources to be used more efficiently. In contrast, a dedicated company intranet deployment may leave resources idle during periods of low demand.
2. No Downtime
Another advantage of microservices being "independently deployable" is that there is no downtime. A new version of a microservice can be rolled out incrementally, coexisting with the old version before eventually replacing it.
The service must, of course, be written to support this use case. Being stateless, as well as "highly testable," aids in ensuring that the new service operates without regression before completely replacing the old service.
3. Intelligent Deployment
Kubernetes is a free and open-source orchestration tool for container deployment, scaling, and management (see below for more discussion of microservices and containers). Canary testing of coexisting versions of a microservice is simple with a service mesh-enabled Kubernetes platform. Weightings, HTTP headers, or a variety of other criteria can be used to shape or route traffic in order to gradually ramp up work on the new service. Before the old version is completely replaced, unwanted behavior can be detected. If the tests fail, reverting to the previous version of the microservice restores the expected behavior.
4. Polyglot Programming for Innovation
Assume a team joins a project to introduce a new feature that will be very appealing to end users. This existing project is mostly written in Go, but the new team is mostly made up of node.js developers. Microservices that are "loosely coupled" and "contractual" provide an ideal environment for a polyglot programming model because teams can use whichever language they prefer to produce the new feature quickly. Another key benefit of microservices is faster time to market, which can be a huge business differentiator.
It is debatable whether mixing languages has any disadvantages. However, if a team is much more familiar with one language than another, that team is much more likely to write "highly maintainable" code in that familiar language.
In the case that teams are simply curious about new technology and are willing to experiment with a new language; there are no worries of that experiment failing: microservices are "fungible," so simply rewrite the microservice.
5. Refactoring, Rewriting, and Decomposing
A legacy monolithic application can be gradually decomposed into microservices using the aforementioned polyglot programming model. While the legacy application is still being phased out, this incremental progression enables the other benefits of microservices.
Another key benefit of microservices is faster time to market, which can be a huge business differentiator.
6. Logic and Responsibilities Are Separated
Large projects are typically complicated. There is no way for a single team to know everything. Furthermore, teams may be purposefully isolated from other areas of the project for compliance or security reasons. A "loosely coupled," "independently deployable," "specialized," and "contractual" microservice enables teams to focus on business logic in their area of expertise or access.
7. Design Patterns for Error Handling and Resilience
Failure is an unavoidable fact of life, so if you must fail, fail small. The circuit breaker pattern is frequently used to prevent systemic failure caused by a root cause in a single isolated component. Inserting control points between microservices is one way to introduce the circuit breaker pattern as they communicate with each other to perform work. A service mesh-enabled Kubernetes platform, for example, includes built-in mechanisms for introducing circuit breakers and leveraging the benefits of microservices.
Microservices and Containers
Containers are the ideal platform for delivering microservices. Why? A container specializes in providing a compact, complete, portable, and immutable runtime environment for a process, adhering to the Unix philosophy of "do one thing well" (in this case a microservice). All dependencies, libraries, and executable code are packaged separately and versioned. A container can run on a variety of different systems thanks to abstractions that hide details about the target platform, enabling "decentralization," which is a key feature of a microservice. To ensure that a microservice is "independently deployable," "fungible," and "loosely coupled," a container should only package one microservice. Because of the "focused and specialized" nature of a microservice, a large number of microservices are typical, as are a large number of containers.
A container orchestration platform is required not only to manage the lifecycle and resource consumption of the containers, but also to introduce observability, resiliency patterns, and rapid deployment. As part of a comprehensive container management strategy, a Kubernetes platform can assist teams in reaping all of the benefits of a microservices architecture.
Disadvantages of Microservices
When deciding whether a microservices architecture is right for your organization, it's critical to consider both the pros and cons. We already discussed the benefits of microservices. We'll go over some of the perceived issues with microservices here.
We previously discussed the size of a microservice and how it influences its scope. A microservice, taken to its logical conclusion, can be too small. If a microservice is too small, it will likely spend the majority of its time communicating with other microservices, introducing latency and generally thrashing. Other microservices may be slowed as a result of this thrashing, especially if using a message bus for inter-service communication, as the bus may become saturated with messages (in this case a circuit breaker pattern can help, but is likely just a crutch so beware).
Microservices running in containers managed by a Kubernetes platform can be difficult to configure. A project must be large enough to justify the costs of managing microservices, deployment automation, and infrastructure. Again, size is arbitrary. If the project team(s) believes they have a thorough understanding of the entire scope of the project, a simpler, monolithic architecture may be more appropriate. However, if you anticipate a large, complex project with a high level of uncertainty, the benefits of a microservices architecture may be ideal.
Finally, some teams consider microservices' loosely coupled nature to be an information barrier. Determining what a microservice does can be difficult if it was implemented with insufficient observability. Service meshes are great for introducing observability, but when used incorrectly, they can introduce enormous complexity and unintuitive behavior.
Utilize the Benefits of Microservices in Your Organization
Today's accelerated rate of technology adoption necessitates a flexible platform that facilitates the adoption of new ideas and concepts. Microservices allow for rapid development in smaller, more manageable units of change. While this architecture pattern is not appropriate for every team, there are numerous microservices benefits that, when used correctly, can contribute to your organization's improved innovation, productivity, business logic scoping, resilience, and high scalability.
Need help reducing your deployment failures and boosting the speed of your software development? Get a free consultation with our certified DevOps team today!