Which Kubernetes Metrics Should You Be Tracking?

Kubernetes metrics provide critical visibility into cluster health, resource utilization and application performance. Understanding which metrics to track helps IT operations teams identify bottlenecks, optimize resource allocation and maintain reliable containerized workloads. This comprehensive guide explores the essential Kubernetes metrics you should monitor, why collection is challenging and how to implement effective monitoring strategies for your enterprise environment.

What are Kubernetes metrics?

Kubernetes metrics are quantitative measurements that provide insights into the performance, health and resource consumption of your cluster and its components. These metrics include data about CPU and memory usage, network traffic, pod status, node health and application-specific performance indicators.

Kubernetes components emit metrics in Prometheus format, a structured plain text format designed so that both people and machines can read it. The platform exposes dozens of built-in metrics through the metrics API, covering everything from basic resource utilization to complex scheduling decisions and control plane operations.

Two complementary add-ons help aggregate and report valuable monitoring data from your cluster: Metrics Server and kube-state-metrics. While Metrics Server focuses on resource usage statistics, kube-state-metrics provides cluster state information about Kubernetes objects like nodes, pods and deployments.

Why is Kubernetes monitoring so important?

Monitoring the health of your Kubernetes cluster is crucial to understand the issues that affect it. You may find out how many resources the cluster uses and how many applications run on each cluster node. Without proper visibility, teams struggle to identify performance bottlenecks, resource constraints and potential failures before they impact end users.

Monitoring Kubernetes provides visibility into the health, performance, and availability of an application running on a Kubernetes cluster, making it easier to optimize resources and cost, improve security and maintain high availability. IT operations teams need real-time insights to make informed scaling decisions, detect security threats and ensure SLA compliance across distributed workloads.

The complexity of containerized environments makes monitoring essential for operational success. Using a Kubernetes monitoring strategy for your clusters has numerous advantages, especially when it comes to reliability, as Kubernetes deployments can be unreliable due to their complexity and the difficulty in determining the underlying source of problems.

Why collecting Kubernetes metrics is challenging

What makes Kubernetes monitoring tricky is that you need to collect and correlate metrics from so many distinct resources. That’s because Kubernetes is not just one thing. It is a conglomeration of different things: a control plane, nodes, pods, a key-value store‌ and a whole lot more.

Because Kubernetes workloads are highly dynamic, ephemeral and are deployed on a distributed and agile infrastructure, Kubernetes poses a unique set of monitoring and observability challenges. Traditional monitoring approaches designed for static infrastructure cannot effectively handle the fluid nature of containerized environments.

Several factors contribute to the monitoring complexity:

• Scale and cardinality: Kubernetes generates a large number of metrics, which can be overwhelming for monitoring tools and operators. It can be difficult to identify which metrics are most important and relevant for a specific use case.
• Dynamic infrastructure: Kubernetes is designed to be dynamic and flexible, which means that pods and containers can be added, removed‌ or moved between nodes frequently. This dynamic nature of Kubernetes environments can make it challenging to track the location and status of each component at any given time.
• Component interdependencies: While many metrics are accessible through the Kubernetes api-server, there is no correlation of all the signals that are exposed and this task is left down to the observer. The metrics and signals provided by the Kubernetes API is raw and does not easily give you insights.

The five Kubernetes metric types to track

Effective Kubernetes monitoring requires tracking metrics across multiple layers of your infrastructure. Here are the five essential categories:

1. Kubernetes cluster metrics

Cluster-level metrics provide a high-level view of your entire Kubernetes environment’s health and resource utilization. Monitoring Kubernetes cluster metrics allows you to gain valuable insights into cluster health status, resource utilization, deployments‌ and more.

Key cluster metrics include:

• Overall CPU and memory utilization across all nodes
• Total number of nodes and their status (ready, not ready, unreachable)
• Cluster capacity and resource allocation
• API server request rates and latency
• Scheduler performance and queue depth

Some critical metrics to monitor include node resource usage: metrics like disk utilization, memory and CPU usage, and network bandwidth. These indicators help you decide whether to change the size and number of cluster nodes.

2. Control plane metrics

Control plane metrics in Kubernetes provide information about the performance of control plane components – such as the API server and the Etcd key-value store. You can track these metrics to monitor how many resources these components are using and how utilization trends change over time.

Critical control plane metrics include:

• API server request duration and error rates
• Etcd database size and operation latency
• Scheduler throughput and latency
• Controller manager work queue depth
• Certificate expiration times

Control plane metrics also offer information such as how long it’s taking the scheduler to schedule Pods and how many Pods are in the queue to be scheduled. These insights help identify bottlenecks in cluster operations and ensure reliable workload placement.

3. Node metrics

Node metrics report the total disk, CPU, and memory usage of nodes within a Kubernetes cluster. You can use these metrics to track the state of your cluster as a whole, but you can also focus on individual nodes, which is valuable if you want to troubleshoot an issue with a particular Pod, or make sure your Pods have enough resource capacity to support workload needs.

Essential node metrics include:

• CPU utilization and load averages
• Memory consumption and availability
• Disk space utilization and I/O operations
• Network throughput and packet statistics
• Node conditions (ready, memory pressure, disk pressure)

For example, by using the appropriate metrics, you can track how many nodes are not ready. This is valuable for getting insight into issues with the stability of your nodes and getting ahead of situations where your cluster runs into serious issues due to a lack of available nodes.

4. Pod metrics

Pod-level metrics provide detailed insights into individual workload performance and resource consumption. Pod metrics are critical for understanding resource utilization and allocation to guarantee the pods and containers operate without causing performance issues for applications.

Key pod metrics include:

• CPU and memory requests versus actual usage
• Container restart counts and failure rates
• Pod startup and termination times
• Network I/O and connection statistics
• Storage volume utilization

By monitoring CPU and memory limits, administrators can identify containers that frequently hit their resource limits. These limits may need to be scaled or optimized to ensure fair resource distribution and maintain cluster stability.

5. Application metrics

Application-specific metrics provide visibility into your workloads’ business logic and user experience. There are situations where a pod could be running and operating as expected. However, the underlying binary/app running within the pod is not as stable as intended. Hence, you may consider monitoring the RED metrics (request rate, error rate, and duration) to help you evaluate the performance and availability of applications running in pods.

Important application metrics include:

• Request rates and response times
• Error rates and success percentages
• Business-specific KPIs and transactions
• Database connection pools and query performance
• Cache hit rates and efficiency

Kubernetes metrics examples

Understanding specific metrics helps teams implement effective monitoring strategies. Here are some commonly tracked Kubernetes metrics:

• Resource utilization metrics
• Availability metrics
• Performance metrics

How to monitor Kubernetes metrics

Monitoring Kubernetes effectively requires combining native tools with specialized monitoring platforms. Kubernetes metrics can be monitored natively in Kubernetes or via third-party tools.

Kubernetes metrics server

The Kubernetes Metrics Server is a lightweight, scalable source of container resource metrics for Kubernetes built-in autoscaling pipelines, such as the Horizontal Pod Autoscaler and the Vertical Pod Autoscaler.

Metrics Server collects resource usage statistics from the kubelet on each node and provides aggregated metrics through the Metrics API. Metrics Server stores only near-real-time metrics in memory, so it is primarily valuable for spot checks of CPU or memory usage, or for periodic querying by a full-featured monitoring service.

Third-party Kubernetes monitoring tools

Third-party Kubernetes monitoring tools help achieve a more scalable and actionable view of the Kubernetes environment, ensuring optimal performance and reliability. These solutions offer several advantages over native tools:

Enhanced capabilities: Third-party solutions typically collect a broader range of metrics, including custom application metrics, which give a fuller view of the cluster’s health and performance.

Scalability: These tools can handle the complexities of large, dynamic environments, making them suitable for monitoring extensive Kubernetes deployments with numerous nodes and pods.

Integration: They often integrate with various other tools and platforms, providing a more unified and extensible monitoring solution that can incorporate logs, traces, and other observability data.

Popular third-party monitoring solutions include:

• Prometheus: Prometheus is practically tailor-made for Kubernetes. Its native service discovery detects new pods, nodes, and services in real time, automatically scraping metrics as workloads scale or shift
• Grafana: Provides visualization and dashboard capabilities for metrics analysis
• Kubernetes monitoring tools that offer comprehensive observability platforms

Best practices for tracking Kubernetes metrics

Implementing effective Kubernetes metrics monitoring requires following proven strategies:

Establish metric hierarchies: Start with cluster-level visibility before diving into granular pod and application metrics. This simple example shows the value of monitoring the metrics of each Kubernetes layer. Cluster-wide metrics provide a high-level overview of Kubernetes deployment performance, but you’ll need those lower-layer metrics to identify problems and obtain useful insights.

Focus on actionable metrics: Avoid metric overload by concentrating on indicators that directly correlate with user experience and system reliability. Prioritize metrics that enable proactive problem resolution over those that merely describe system state.

Implement automated alerting: Configure intelligent alerts based on metric thresholds, trends and anomalies. Combine multiple metrics to reduce false positives and ensure alerts provide sufficient context for rapid response.

Correlate metrics across layers: By combining logs and performance information, DevOps teams can gain deeper insights into the performance and health of their Kubernetes environment and quickly identify and resolve issues.

Standardize labeling: Use consistent labeling strategies across all metrics to enable effective filtering, aggregation and correlation. Proper labeling becomes crucial when managing metrics at scale.

Regular metric review: Periodically evaluate your metric collection strategy to ensure it evolves with your infrastructure and application changes. Remove outdated metrics and add new ones as your Kubernetes deployment grows.

Tracking Kubernetes metrics with SUSE

SUSE provides comprehensive solutions for Kubernetes metrics monitoring through SUSE Rancher and integrated observability tools. Our platform simplifies the complexity of multi-cluster metrics collection while providing enterprise-grade reliability and security.

SUSE’s approach to Kubernetes observability includes:

• Integrated Prometheus and Grafana deployments
• Automated metrics collection across hybrid and multi-cloud environments
• Pre-configured dashboards for essential Kubernetes metrics
• Centralized cluster management with unified observability

Our observability solution reduces the operational overhead of metrics monitoring while ensuring you have complete visibility into your Kubernetes infrastructure’s health and performance.

Keeping your metrics strategy current

Effective Kubernetes metrics monitoring forms the foundation of reliable container operations. By tracking metrics across cluster, control plane, node, pod and application layers, IT operations teams gain the visibility needed to maintain high-performing, secure and cost-effective Kubernetes deployments.

The key to success lies in implementing a structured approach that balances comprehensive coverage with operational simplicity. Start with essential metrics, gradually expand your monitoring scope and continuously refine your strategy based on operational experience.

SUSE’s integrated observability platform helps organizations implement robust Kubernetes metrics monitoring without the complexity of managing disparate tools. Our solution provides the enterprise-grade reliability and scalability needed for production Kubernetes environments. If you are interested in a 30 day free trial, visit SUSE Cloud Observability on the AWS Marketplace. 

Kubernetes metrics FAQs

Why is Kubernetes monitoring important?

Kubernetes monitoring provides critical visibility into cluster health, resource utilization and application performance. Monitoring helps operators quickly identify and troubleshoot issues as they arise, which can help minimize downtime and ensure a good user experience. Without proper monitoring, teams cannot effectively manage resource allocation, detect security threats or maintain SLA compliance in dynamic containerized environments.

How can you collect Kubernetes metrics?

In Kubernetes, application monitoring does not depend on a single monitoring solution. On new clusters, you can use resource metrics or full metrics pipelines to collect monitoring statistics. The Metrics Server provides basic resource usage data, while third-party tools like Prometheus offer comprehensive metric collection capabilities.

How does tracking Kubernetes metrics improve performance?

Tracking Kubernetes metrics enables proactive performance optimization through resource utilization insights, bottleneck identification and predictive scaling decisions. Monitoring the right metrics, such as CPU usage, memory consumption, and pod utilization, helps teams spot underused resources, fine-tune scaling policies, and cut down on wasted infrastructure costs. Metrics also enable automated scaling mechanisms like the Horizontal Pod Autoscaler to respond dynamically to changing workload demands.