Three Best Practices for Ensuring Service Quality in Microservice Applications
Early digital transformers like Netflix, Walmart and Amazon recognized early that the key to keeping customers happy is flawless application services that keep pace with customer demand and perform better than the competition. In short, he or she who codes the fastest wins.
Different strategies and architectures have been widely adopted as a result of this need to release code and applications faster in order to out-perform the competition. There was a transition from waterfall to agile; the break down of silos between development and operations — also known as DevOps; and most recently, we’ve seen companies decomposing large, complex, monolithic code bases into much smaller and easier to develop units resulting in microservices architectures. Each microservice typically provides only a few functions that are accessible via API calls, making it much faster to develop and release each individual microservice.
Digital businesses are using microservices to quickly deploy application services and give customers the latest, greatest application features and functionality. But microservices introduce a new game for DevOps teams, adding complexity and putting service quality at risk. The dynamism that microservices bring to today’s applications requires three best practices for monitoring and managing them and their applications for service quality — Discovery, Understanding and Investigation.
Discovery Must Be Automatic, Immediate and Continuous
Microservices architectures are dynamic in nature. They scale horizontally to accommodate spikes in workload at a granular level. For example, in an online banking application, there might be a usage spike on Fridays when people are digitally cashing their paychecks or checking their account balances. The “login,” “check imaging,” and “account balance” functions will all experience a large spike in workload which could result in poor performance or service disruption in traditional architectures. In a microservice architecture you spin up new instances of the services that provide “login,” “check imaging,” and “account balance” functionalities. This level of granular control helps ensure customer satisfaction while focusing extra compute resources exactly where they are required.
There are many benefits with microservices architectures but there are also challenges that must be understood and addressed. Traditional applications were composed of tens to hundreds of different components. Microservices applications can easily grow to thousands of components all interacting to provide a complete application. This massive number of dynamically changing interconnected components creates difficulty in management and troubleshooting. Combine this complexity of scale with new code release rates of hours or days and the potential for problems increases exponentially. Effective monitoring becomes a key success factor within microservices architectures.
Monitoring has the following tangible benefits when practicing agile development, DevOps, and using microservices architectures:
- Understand the impact of every new code deployment — integrate with continuous integration / continuous delivery tools for rollback or full rollout.
- Faster identification of root cause of poor performance or errors in production.
- Full understanding of downstream impact caused by microservice outages.
- Track the status of your entire estate at every moment.
- Determine when to scale up or scale down — right size your environment at every moment to ensure customer satisfaction and keep costs in check.
The first step to monitoring microservices and maintaining service quality for a dynamic application is to keep pace with the rapid rate of change. Only automatic, immediate and continuous discovery of new and changed application components will ensure accurate data collection from dynamic applications comprised of thousands of building blocks — including microservices.
Let’s look at the various components that must be monitored, yet can change at any given time:
- Physical: Servers, network adapters, disks — even though every item listed here is now virtualized they are still thought of as “physical” devices.
- Virtual: Containers, processes, OS VMs, Application VMs (JVM, CLR).
- Logical: Clusters, transactions, services, applications, line-of-business groupings.
Automatic (happens without human interaction as components change or are added), immediate (within a second) and continuous (never-ending) discovery is a foundational component to maintaining application quality of service.
“Any fool can know. The point is to understand.”
In the words of Albert Einstein, “Any fool can know. The point is to understand.” That is true for monitoring microservices. It’s not enough to discover and know all the components. If you don’t understand their relationships and dependencies, there is no way to properly manage an application and quality of service.
Once components are discovered, understanding their interdependencies, the application’s “normal” performance and behavior, and having expert knowledge of expected behaviors must be the next step.
Interdependencies are determined in two main ways:
- Observation — observe all interactions between components as they communicate with each other.
- Inheritance — within a single host, software can determine that a host runs a container which runs a process which consists of a JVM, which is actually a Tomcat application server.
Combining the results of observation and inheritance we can form a complete understanding of any application at any given point. But remember that we must continuously and immediately collect new observation and inheritance data to maintain accuracy.
Artificial Intelligence for Faster, Accurate Incident Response
As we work to ensure the service quality of every microservice and the applications they support, we need to be prepared to respond immediately when service is compromised. With Discovery and Understanding of the microservice and application handled, we are well prepared to investigate any service issue. But investigating an issue using traditional manual methods and tools is slow and not the best way to ensure service quality and keep customers happy.
The rich information gained from thorough discovery and understanding allows DevOps teams to automate the investigation process to quickly determine root cause or even predict failure points in the future.
Artificial intelligence can only be effective if it’s applied to an accurate and detailed data model. AI techniques, such as neural networks and deep learning, perform the tasks that no human can perform at massive scale:
- Behavioral learning to understand what normally happens at any time of day, the day of the week, the day of the month, the day of the year, etc.
- Predictive analytics to understand and avoid imminent problems.
- Automatic root cause analysis.
- Downstream impact assessment.
- “What-if” modeling scenarios.
The ability to identify the root cause along with every downstream impact of a single issue within a multi-thousand node microservices application is an impossible task for humans and must now be performed by AI.
As microservices architectures permeate today’s dynamic applications and grow at an estimated 16 percent CAGR through 2023, organizations that want to compete and win will need to make sure the service quality of their applications is flawless. Practicing good microservice discovery, understanding and investigation can help keep microservices and the applications they support operating well and keeping customers happy.
Feature image via Pixabay.