The Six Pillars of Modern Dynamic Application Management

Understanding how to manage service quality in this new age of microservices applications takes more than just re-purposing APM or Transaction monitoring software.

The recent eBook Service Quality Management in the Microservices Age discusses what’s needed to “thrive in the brave new world of Microservices”. The concepts are a good start, but they inspired us to think about what you MUST have to manage modern applications (microservices, containerized, cloud, etc.). What we came up with are pillars of application management – six fundamental items that are required to effectively manage today’s modern dynamic applications.

Why Are Modern Applications More Difficult to Monitor and Manage?

Like the number of components in a modern app, the reasons are varied and numerous. Let’s start with the idea of loosely coupled application components. We saw some of this as SOA emerged as a primary application architecture, but never to this extent. What started as a few calls in the middle of a SOA App has ballooned into an all out blitz of constant change.

Whether you’re talking about the sheer scale of components, the rate of change, or the ever-growing list of various microservice / container technologies, automation is required. Why? Because any individual (or team) cannot glean all the necessary data to make every correct decision.

From automation to service level management, everything has to change for DevOps to effectively manage the modern application.  In fact, six distinct things must be considered.

So here are the Six Pillars of Modern Dynamic Application Management

pillars

  1. Automatic and Continuous Discovery
    The only constant in modern applications is change, whether due to microservice architecture, containerized app components, or simply more agile delivery execution. To effectively manage these applications, DevOps needs an up-to-date and accurate picture of application components and their dependencies.Just as important, that picture must update continuously as changes occur in applications.
  2. 1 second granularity of metrics
    60-second timeframes for measurements just won’t get the job done. In traditional applications, Ops teams could get away with missing short time spikes, but modern applications operate at a different level of speed, scale and dynamism. It’s important to know when any performance spike occurs, even if only for a few seconds.
  3. 3 seconds to visualization
    As discussed, modern applications change all the time. Microservices are deployed, updated and discarded. Containers are spun up and destroyed quickly. In this world, the only way to keep the map (and understanding) of the application architecture accurate is to update within a few seconds.Building on the ideal of 1-second metric granularity, your tools must be able to reflect any changes to the application environment within 3 seconds of the change. Not only does this keep the tooling aligned with reality, it also allows the DevOps team to know almost instantly when an update is satisfactory or if it’s problematic.
  4. Capture Details of EVERY Request
    One tenet of modern applications is that every request is delivered independent of other requests. That means that each request has a unique path through the mesh of microservices and containers that make up the app.Since presumably the application is critical to the business, and each request is processed uniquely, this demands that the details of every request are captured in a way that you can identify and analyze any unique request.

    In this environment, the only way to manage overarching service quality is capture every request as a Trace. This also helps when constructing all possible paths through the application infrastructure for similar requests.

  5. Focus on What Matters
    By design, modern applications have extreme complexity built into the system. The scale and dynamic nature of hybrid cloud environments and containerized microservices applications make it difficult to see which components make up a given application or service, making it especially hard to troubleshoot any problems.Focus is critical in this dynamic environment – whether it’s filtering out systems that aren’t part of a specific application or correlating performance and change events to a specific service incident.

    And this ability to focus should be intuitive, not a set of scripts and complex regular expression programming to filter out things. Only then can everyone on the Ops team get the data they need when they need it.

  6. Leverage Artificial Intelligence
    Modern applications are simply too complex for humans to effectively manage on their own. The dynamism of structure, the complex dependencies and the sheer scale are hard enough to handle – but when you throw in the need to deliver high service quality, intelligent machine assistance is required to handle all the necessary management tasks. Where and how can (or should) artificial intelligence be applied?

    • Selecting which Key Performance Indicators (KPIs) are used to measure service quality
    • Understanding the difference between noisy IT events and service-impacting incidents
    • Determining the triggering event of a service incident
    • Identifying the most likely root cause of a problem

    And it only gets worse with more applications, a larger number of technologies, the use of microservices, containers constantly spinning up and down and user load exponentially growing.

    Humans just can’t stay on top of service quality management with these complexities, especially as the number of elements gets into the hundreds.

So there you have it – the 6 Pillars of Modern Application Management. Stay tuned as we examine each pillar individually. In the meantime, sit back, relax and check out the eBook – “Service Quality Management in the Microservices Age”.