The Six Pillars of Managing Microservice Applications

It’s a Brave New World of Applications

The modern application stack has evolved. From cloud-native to containers, microservices and kubernetes orchestration, a new set of infrastructure technologies has emerged to help organizations digitally transform and move their applications faster.

In these modern applications, there is one constant – constant change!

To effectively manage modern cloud-native microservice applications, Dev+Ops teams need real-time visibility, automated observability and a way for all application stakeholders to get the necessary data in a way that makes sense to them at the exact time they need it.

Why Are Modern Applications More Difficult to Monitor and Manage?

As organizations adjust their technology stack to facilitate faster development and deployment of their applications, there are new requirements for basic performance monitoring and application observability / visibility.

The challenges of managing performance of modern applications are consistent across programming languages, cloud providers, even different technology choices. What makes these applications difficult to deal with is the vast distributed nature of the applications, coupled with the constant change bombarding both the Dev and Ops teams.

New Application Stack = New Monitoring Requirements

The complete set of requirements to effectively manage these highly dynamic, massively distributed application environments, is specific, and built around the idea of every stakeholder getting the information they need when they need it.

With that in mind, we present the Six Pillars of Managing Modern Microservice Applications, which details out six critical concepts of monitoring and management that are critical to any solution’s ability to provide continuous value to teams responsible for operating these applications.

With a not-so-subtle focus on automation and AI-assisted ise, here are the pillars of effective APM for modern applications. A quick note, though – before we break down each pillar, it’s important to note that if any single pillar is missing, the other 5 collapse. Thus, a solution that provides 1 to 5 pillars will have gaps in its management – gaps that will most likely result in horrible outages and many wasted bridge calls trying to determine what went wrong.

The Six Pillars of Cloud-Native Microservices APM

Automatic, Continuous Discovery & Mapping

Real-Time Full Stack Application Data Model

Precise High Fidelity Visibility

AI-Powered Incident Monitoring, Problem Resolution and Troubleshooting

Cloud, Container & Microservice Native

Integration into Development / Deployment / CICD Pipeline Toolset

Automatic, Continuous Discovery & Mapping

There is an old saying in computing; “garbage in, garbage out”. If we are to apply an AI approach to performance management, then the core model and data set must be up-to-date and impeccable. Meanwhile, DevOps needs up-to-date visibility for

an accurate picture of their application’s structure and dependencies. With zero configuration, Instana’s Agent continuously and automatically discovers components, architecture and dependencies of the application’s full technical stack as well as the request patterns, or map, of the distributed services.

Precise High Fidelity Visibility

To empower AI, precision and accuracy of data are required. After automatically discovering the components and structure of the application, Instana collects the industry’s most accurate monitoring data: metric data is streamed at 1 second granularity, and every request through the application is captured in a Trace.

This data is the source for our AI training and the basis for giving the user deep visibility into microservice applications.

Instana collects all the needed data automatically and in realtime:

• Time-series metrics for the full stack – including infrastructure, cloud, container, process, middleware and application metrics
• Changes – all changes, events and errors for all monitored components
• Distributed Traces – full distributed traces mapping every request and transaction

Cloud, Container & Microservice Native

Modern applications continuously change, are deployed across hybrid clouds, leverage containers and orchestration (like Kubernetes and Mesosphere), all in the name of high speed delivery. Meanwhile, the microservice architecture spawns wide diversity
-each engineer can choose the programing language, middleware and databases best suited to code their microservice. Scale, complexity and constant change are the new realities. Traditional Monitoring and APM tools were not designed for these diverse and dynamic use cases.

Instana is designed to operate in the modern world. With zero configuration, Instana naturally aligns with the infrastructure, clouds, containers, orchestrators, middleware and languages to automatically keep up with, and visualize, your microservice application.

Even in constantly changing environments like Kubernetes, Instana automatically discovers the full stack of your application and manages its performance.

Real-Time Full Stack Application Data Model

The core technology powering Instana is the internal data model, the Dynamic Graph.

• • The Graph is a model of your discovered application: all physical and logical components, their technology components, dependencies and configuration.

 

• • The Graph also understands logical components like traces, applications, services, clusters and tablespaces.

 

• • The Graph maintains the dependency models needed to enable the AI powered precise troubleshooting, prediction and problem resolution capabilitiesof Instana.

 

• The Graph is also flexible, allowing Instana to dynamically describe architectures of any complexity, layering, virtualisation etc., and thus is robust to future architecture trends.

Without a strong model of what an application is, there can be no intelligent analysis of performance, root cause or predictions.

AI-Assisted Monitoring and Troubleshooting

It bears repeating that modern applications (cloud-native, microservices, container-based, orchestrated, multi-cloud) are extremely complex and dynamic. The only constant among these is that there’s constant change. In this type of system, AI must be brought to bear to discover and understand the components, dependencies and overall health of the system.

For AI to effectively work, there must be a robust underlying model that includes:

• Automatic discovery of all system components and all inter-dependencies between those components
• Configuration data for each system component
• Performance data for each component
• Understanding of how components are used together to produce desired outcomes

Next is real-time detection AND understanding of any events (new components, updated components, eliminated components).

The model and real-time event detection drives the AI-Assisted discovery and mapping, deployment, monitoring and troubleshooting needed for production application monitoring.

The best way to break the data into both machine and human understandable pieces is through the “Google Golden Signals” – Transaction Rate, Error Rate, Latency and Saturation. These derived metrics together represent the overall health of the application system.

The final piece of monitoring a complex system is to eliminate the noise – with millions of metrics and events, how do you keep the human operators from being overwhelmed. The answer is simpler than you might think – focus on service impacts only. This leverages the most constrained resource (human operator time) to provide the most positive impact (maximizing application user experience).

Even with a “smaller” focus on service level incidents, though, it’s practically impossible for any single stakeholder (whether Dev or Ops) to understand how pieces work together, and where any individual change might impact overall service levels. That’s where the final piece of AI is applied, to take the incident and events, correlate through the dependency model and identify the triggering event (time, event, system, specifics) giving the monitoring users the exact information they need to find AND FIX the problem before major service impacts occur.

Integrated into Dev and CI/CD Pipelines

As application teams start taking advantage of the new technology and architecture choices, releases become more frequent, deployed by more individuals, and impacting more end users. Modern APM solutions must recognize this shift in the application delivery process and integrate with the latest set of mission critical tools – Development and CI/CD pipeline management solutions.

Of course, effectively managing release performance in an integrated manner requires a few capabilities that we’ve previously discussed – namely 1-second metric granularity and 3-second alerting. After a software release, the faster that the Ops team can know that whether or not the release has issues, the better.

Beyond the fidelity and granularity of the metric set, it’s important for the APM solution to understand – programmatically – when releases occur, what their impact is, and whether or not they’ve achieved the appropriate performance and success levels. There are three critical capabilities you should be looking for:

• Real-time update / change detection
• Release Identification & Tracking
• Immediate feedback on new component performance

Only with all three can you hope to have an effective APM tool as it relateds to modern software practices such as continuous delivery and agile development cycles.

The BONUS FEATURE you want to be looking for is integration with a release management solution, such as Jenkins – that allows you to not only auto-tag releases, but also understand when potential hotspots are.

About Instana

Instana, an IBM Company, provides a real-time, automated Enterprise Observability Platform that includes application performance monitoring capabilities to businesses operating complex, modern, cloud-native applications no matter where they reside—on premises or in public and private clouds, including mobile devices or IBM Z® mainframe computers. Users can control modern hybrid applications with Instana’s precise metrics, full end to end traces for all transactions and AI-powered contextual dependencies discovery inside hybrid applications.

Instana helps System’s Reliability Engineers improve the reliability and resiliency of cloud-native applications by preventing issues from turning into incidents and by providing fast remediation times when incidents occur. Instana also provides visibility into development pipelines to help enable closed-loop DevOps automation with actionable feedback
for optimizing application performance, enabling innovation, mitigating risk, and managing cloud technology expenditures.

For more information, visit instana.com.