Monitoring Apps in Containers:3 Novel Ways SteelCentral You Covered
Everyone seems to be thrilled about containers and microservices. But if you use them you've still got to figure out how to monitor and manage the performance of your apps and the overall system. The good news: the latest version of Riverbed SteelCentral provides a revolutionary approach to container monitoring for the DevOps team. We spoke to Riverbed Senior Product Manager Peco Karayanev to find out more.
A brief introduction to containers
A container is a way to bundle and run an application, or a component of an application, in a way that abstracts it away from the operating system. Applications broken up into separate functions, referred to as microservices, can be separated across a distributed architecture to take better advantage of the resources they’re given. Containers are managed by orchestrator software like Kubernetes or Docker Swarm.
"Containers and microservices let you break an application into small parts that are interoperable across different environments," says Karayanev. "They help you become more agile in how you develop new functionality. In my 20 years in IT, I've never seen a technology adopted so quickly — even in risk-averse fields like finance."
But like all new technologies, containers and microservices post challenges, particularly when it comes to monitoring the performance of containerized apps. The latest version of SteelCentral is here to help you meet those challenges in three remarkable ways:
- You can instrument containers without modifying their internal code or the container image
- You can keep up with the increased volume of transactions that container-based systems generate
- You can correlate application forensic log data with our performance transaction trace data to more quickly troubleshoot problems with container-based apps
Let's look at each of these benefits in more detail.
1. Instrumenting containers
As the name implies, the benefit of containers is that they're self-contained. But you don't want black-box components whose performance you can't monitor. SteelCentral automatically instruments the container process at the system level; the instrumentation is injected when the application launches — all without having to change code or application configurations.
"That's been our key innovation," says Karayanev. "You can still adhere to the core principles of containers, but any additional bits that are needed you attach to the container from the outside, allowing you to observe what’s happening inside the container and the application.”
2. Keeping up with the volume
A distributed container-based app naturally generates large numbers of transactions as all those components communicate with each other. Those systems are dynamic, too, with different containers being active in different times. Keeping extensive forensic and performance history on all that traffic is necessary to ensure a quick identification of design and operational flaws — and that's exactly what SteelCentral makes possible.
"Our approach to big data actually fits this model very well," says Karayanev, "because we record every transaction in detail and preserve that historical record. There’s no guesswork, no extrapolation or simulations. If you have a performance or functional problem, you can go back in time and see the exact state of the entire container-based system to see what transpired where. You can very quickly diagnose where the bottlenecks are."
3. Incorporating log and transaction data
Application monitoring involves keeping tabs on both performance and functional accuracy. When it comes to container-based apps, SteelCentral doesn't just capture performance data and measure transactions, but it actually incorporates log data as well so you don't have to manually correlate the two when you're troubleshooting.
"Imagine you have a multitier transaction implemented in the container microservices world," says Karayanev. "For a particular transaction, you have a container instance with a business logic error — it's logging a statement that 1 + 1 = 0, for example. From a performance perspective, there’s nothing wrong: the transaction executed! It was just delivering incorrect results. With SteelCentral you can capture the entire path end-to-end and track down the error to a specific function."
Get started today
The best part: these features are available as part of the newest version of SteelCentral. You access the information through the SteelCentral interface, making container-based apps first-class citizens. As Karayanev puts it, these benefits "make containerized apps more practical to deploy, helping IT very quickly adopt the technology."
And there’s even more news. The latest version SteelCentral also delivers:
- A seamless link between end user experience and network performance management
- Adaptations to the big data requirements brought on by digital transformation
- The Riverbed Performance Command Center (PCC) for AWS and Azure, accelerating the transition to digital experience monitoring
- SteelCentral End User Experience (Aternity) integration with ServiceNow to vastly improve first call resolution
Get a two-week free trial to test-drive the new SteelCentral, or contact your Riverbed sales rep to discuss an upgrade.