Design and operate better applications in Kubernetes with extended insights into cross-container communications

Kubernetes at scale in the enterprise is complex. Systems are constantly changing, with pods existing only briefly to perform tasks before they’re terminated. In such circumstances, it’s challenging to investigate the reasons for unexpected behavior or traffic between pods.

Dynatrace is the only Kubernetes monitoring solution that provides continuous automation and full-stack automated observability without changing code, container images, or deployments. By deploying OneAgent via the OneAgent Operator or Helm in Kubernetes environments, application teams can understand the performance of their applications and ensure that they deliver the expected value.

Get full visibility into Kubernetes container-to-container communications

To once again push the boundaries of automatic, AI-based Kubernetes monitoring, we’ve extended Smartscape, the Dynatrace real-time topology model, with visibility into how processes and containers communicate with each other in Kubernetes.

Full visibility into the internal cluster communication between your pods allows you to easily spot unexpected processes in dynamically changing Kubernetes environments, thus ensuring healthier applications. Now you can:

• Understand the actual architecture of your applications in Kubernetes in real-time
• Understand the impact of third-party services and requests to external APIs

Let’s take a look how each of these advantages reveal themselves in Dynatrace.

Understand the architecture of your applications in Kubernetes in real-time

For this example, we’ll use a simple application called “Online Boutique,” which is based on the Google microservices demo application. Online Boutique has been launched into a Kubernetes cluster that runs in Google Kubernetes Engine (GKE). This sample app is a web-based e-commerce application that consists of a multi-tier microservices architecture, which you can see below.

To visualize this application’s architecture in SmartScape, Dynatrace OneAgent detects all the details of the containers and microservices that are running in this Kubernetes environment.

In this scenario, Dynatrace detects the communication and the current transactional dependency graph of the individual microservices. A new Node.js process has shown up in the detected dependency graph. This is because we extended the original application with an additional PaymentService instance that intentionally leaks memory for demo purposes. There is also an NGINX instance that serves as ingress for the application.

While this was an intentional change, when validating the actual architecture, you’d expect to see such changes easily. Any differences in Smartscape visualization indicate changes to the architecture, even when such changes relate to communications to outdated microservices or changes in deployments.

Understand the impact of third-party services and requests to external APIs

The ongoing and continuous tracking of network and service-level communication of pods in Kubernetes enables Dynatrace to easily discover any unintended egress traffic (i.e., calls to services that are outside the K8s environment).

In the same scenario, Dynatrace detected that there were calls to third-party endpoints for the reporting of telemetry data. This is due to customized monitoring code in the microservices applications that report their telemetry data to these endpoints.

Getting observability into the telemetry data of those apps and services that are in production is key to understanding and proactively improving user experience. However, there might also be third-party libraries or observations that require further investigation.

You’ll likely want to trace back the end-user actions in the browser to specific requests for backend events (including requests to external APIs) to understand how they affected the performance of your apps. As you can see below, the end user experience in this example isn’t great. Dynatrace discovered some JavaScript errors in the HTML markup that was delivered from the frontend.

From here, you can drill down even further to analyze the JavaScript errors and perform a waterfall analysis of the loaded page.

What’s next

In the coming months, we plan to extend Dynatrace Kubernetes support with the following capabilities:

• Network metrics for all containerized environments
• Improved Davis® AI anomaly detection for k8s environments

Feedback?

We’d like to hear about your experiences monitoring Kubernetes environments. Do you have the same certainty and control over your K8s-based applications and services that Dynatrace provides? Have ideas for further improvements? Please share your comments with us at Dynatrace Community.