CristGuard

Programming

Checking Kubernetes pod CPU and memory utilization

19 September 2026 · 11 min read

Checking Kubernetes pod CPU and memory utilization

Understanding resource consumption within your Kubernetes clusters is crucial for maintaining performance, stability, and cost efficiency. Checking Kubernetes pod CPU and memory utilization allows you to identify bottlenecks, optimize resource allocation, and prevent applications from crashing due to resource exhaustion. Ignoring these critical metrics can lead to unpredictable application behavior, increased operational costs, and a frustrating experience for users. This comprehensive guide will walk you through the various methods and tools available to effectively monitor and manage your Kubernetes pod resource usage. We’ll delve into practical examples and best practices, ensuring you gain the insights needed to keep your Kubernetes deployments running smoothly and efficiently. Regular monitoring isn’t just a good practice; it’s essential for a healthy and scalable Kubernetes environment. Failing to do so can result in wasted resources and a negative impact on overall system performance, potentially leading to service disruptions and escalating costs.

Why Monitor Kubernetes Pod Resource Utilization?

Monitoring resource utilization in Kubernetes is paramount for several key reasons. First and foremost, it enables proactive identification of potential performance bottlenecks. By tracking CPU and memory usage, you can spot pods that are consistently consuming excessive resources, which could indicate inefficient code, memory leaks, or misconfigured resource limits. Addressing these issues promptly prevents them from escalating into critical performance problems that impact the entire cluster. Furthermore, monitoring resource utilization helps optimize resource allocation. Understanding how pods are actually using resources allows you to fine-tune resource requests and limits, ensuring that pods have enough resources to function optimally without over-provisioning and wasting valuable cluster capacity. This leads to significant cost savings, especially in cloud environments where you pay for the resources you consume. According to a recent survey by the Cloud Native Computing Foundation (CNCF), over 60% of organizations cite cost optimization as a primary driver for adopting Kubernetes. CNCF Official Website

Resource monitoring also helps in capacity planning. By analyzing historical resource usage data, you can accurately forecast future resource needs and plan for scaling your cluster accordingly. This prevents resource shortages and ensures that your applications can handle peak loads without performance degradation. Effective monitoring allows you to make data-driven decisions about scaling your Kubernetes infrastructure, optimizing resource allocation, and ensuring the long-term health and stability of your applications. Failing to monitor can lead to reactive fire fighting, which is much more costly and time-consuming than proactive management.

Finally, resource utilization data is invaluable for troubleshooting. When an application experiences performance issues or crashes, monitoring data provides critical insights into the root cause. You can quickly identify whether the problem is related to CPU exhaustion, memory leaks, or other resource constraints, enabling faster and more effective resolution. Proper monitoring dramatically reduces the mean time to resolution (MTTR) for incidents, minimizing downtime and ensuring business continuity. This data-driven approach to troubleshooting is crucial for maintaining the reliability and availability of your Kubernetes applications.

Tools and Techniques for Monitoring Pod Resources

Several powerful tools and techniques are available for monitoring Kubernetes pod resource utilization. One of the most fundamental tools is kubectl, the Kubernetes command-line interface. Using kubectl top pod provides a quick snapshot of the CPU and memory usage of your pods. This is a simple and effective way to get a high-level overview of resource consumption. However, kubectl top pod only provides real-time data and does not store historical information. For more comprehensive monitoring, consider using metrics servers like Prometheus and Grafana. Prometheus is a widely used open-source monitoring and alerting toolkit that collects metrics from Kubernetes nodes and pods. Grafana is a powerful data visualization tool that allows you to create dashboards and visualize the metrics collected by Prometheus. Together, Prometheus and Grafana provide a robust solution for monitoring and analyzing Kubernetes resource utilization over time.

Heapster was one of the earliest tools used for monitoring Kubernetes clusters. It’s now deprecated but worth mentioning as it paved the way for more sophisticated tools. Nowadays, the Metrics Server is a lightweight, cluster-wide aggregator of resource usage data. It collects resource metrics from Kubelets and exposes them through the Kubernetes API server, making them accessible to other tools like kubectl top and the Horizontal Pod Autoscaler (HPA). The HPA automatically scales the number of pods in a deployment based on CPU utilization or other selected metrics. This ensures that your application can handle varying workloads without manual intervention. For example, you can configure the HPA to increase the number of pods when CPU utilization exceeds 70%, and decrease the number of pods when CPU utilization falls below 30%. This dynamic scaling helps optimize resource usage and maintain application performance.

Cloud providers also offer their own managed monitoring solutions, such as Google Kubernetes Engine (GKE) Monitoring, Amazon CloudWatch Container Insights, and Azure Monitor for containers. These solutions provide seamless integration with your Kubernetes clusters and offer advanced features like anomaly detection, alerting, and log aggregation. Choosing the right monitoring tool depends on your specific requirements, budget, and technical expertise. Consider factors like ease of use, scalability, and integration with your existing infrastructure when making your decision.

Step-by-Step Guide: Checking Pod Resource Utilization with kubectl

The kubectl command-line tool offers a straightforward way to check the CPU and memory usage of your Kubernetes pods. This method is particularly useful for quick checks and basic troubleshooting. Here’s a step-by-step guide:

  1. Access your Kubernetes cluster: Use kubectl config use-context to connect to the desired cluster. Ensure you have the necessary permissions to access pod metrics.
  2. Run the kubectl top pod command: This command displays the CPU and memory usage for each pod in the current namespace. If you want to check all namespaces, use the –all-namespaces flag (e.g., kubectl top pod –all-namespaces).
  3. Interpret the output: The output shows the pod name, CPU usage (in millicores), and memory usage (in megabytes). Pay attention to pods with high CPU or memory usage, as they may indicate potential bottlenecks.
  4. Further investigation: If you identify a pod with high resource usage, you can use kubectl describe pod to get more detailed information about the pod, including its resource requests and limits, events, and logs.

For example, running kubectl top pod might produce output similar to this:

NAME CPU(cores) MEMORY(bytes) my-app-pod-7c6d8678f5-xwq47 10m 20Mi my-db-pod-5b8b76f6d4-j9z8r 50m 100Mi

This output indicates that my-app-pod is using 10 millicores of CPU and 20 MB of memory, while my-db-pod is using 50 millicores of CPU and 100 MB of memory. This information can help you identify pods that are consuming excessive resources and require further investigation. Remember that kubectl top pod only provides a snapshot of resource usage at a specific point in time. For historical data and trend analysis, you’ll need to use a more comprehensive monitoring solution like Prometheus and Grafana.

Leveraging Prometheus and Grafana for Advanced Monitoring

Prometheus and Grafana provide a powerful and flexible solution for advanced Kubernetes monitoring. Prometheus collects metrics from your Kubernetes cluster, stores them in a time-series database, and allows you to query and analyze the data using PromQL, its powerful query language. Grafana then visualizes this data through customizable dashboards, making it easy to identify trends, spot anomalies, and gain insights into your application’s performance. Setting up Prometheus and Grafana involves several steps. First, you need to deploy Prometheus to your Kubernetes cluster. This typically involves deploying a Prometheus Operator, which simplifies the deployment and management of Prometheus instances. The Prometheus Operator automatically configures Prometheus to discover and scrape metrics from your Kubernetes pods.

Infographic here
Next, you need to configure Prometheus to collect the desired metrics. This involves defining ServiceMonitors and PodMonitors, which specify which pods and services to scrape metrics from. You can also configure Prometheus to collect custom metrics from your applications by exposing them through HTTP endpoints. Once Prometheus is collecting metrics, you can deploy Grafana and configure it to connect to the Prometheus data source. Grafana allows you to create dashboards that visualize the metrics collected by Prometheus. You can create dashboards to track CPU utilization, memory usage, network traffic, and other key performance indicators. You can also set up alerts to notify you when metrics exceed predefined thresholds. This allows you to proactively identify and address potential performance problems before they impact your users. According to a recent report by Datadog, organizations that use Prometheus and Grafana for Kubernetes monitoring experience a 20% reduction in mean time to resolution (MTTR) for incidents. [Datadog Official Website](https://www.datadoghq.com/). The featured snippet below provides insight into optimal metrics for monitoring.

Featured Snippet: To effectively monitor Kubernetes pods, prioritize these key metrics: CPU utilization (percentage of CPU cores used), memory utilization (percentage of allocated memory used), network I/O (bytes sent and received), and disk I/O (bytes read and written). Tracking these metrics provides a comprehensive view of pod resource consumption, enabling you to identify bottlenecks, optimize resource allocation, and ensure optimal application performance. Establish clear thresholds and alerts for these metrics to proactively address potential issues.

Here are some key benefits of using Prometheus and Grafana:

  • Comprehensive monitoring: Collect and visualize a wide range of metrics from your Kubernetes cluster.
  • Customizable dashboards: Create dashboards tailored to your specific needs and requirements.
  • Alerting: Set up alerts to notify you of potential performance problems.
  • Historical data: Analyze historical data to identify trends and patterns.

Best Practices for Managing Pod Resources

Effectively managing pod resources is crucial for maintaining the health and performance of your Kubernetes cluster. One of the most important best practices is to set resource requests and limits for your pods. Resource requests specify the minimum amount of resources that a pod requires to run. Resource limits specify the maximum amount of resources that a pod is allowed to consume. Setting appropriate resource requests and limits ensures that pods have enough resources to function optimally without starving other pods. It also prevents pods from consuming excessive resources and impacting the overall performance of the cluster. It’s important to perform regular resource right-sizing analyses to determine whether the requested resource limits are in line with actual utilization. This iterative process helps to optimize resource use and prevent waste.

Another best practice is to use resource quotas to limit the total amount of resources that can be consumed by a namespace. Resource quotas prevent individual teams or applications from consuming excessive resources and impacting other teams or applications. They also help enforce resource allocation policies and ensure that resources are distributed fairly across the cluster. Consider implementing pod priority and preemption to ensure that critical pods are always scheduled and have access to resources. Pod priority allows you to assign a priority to each pod, with higher priority pods being scheduled before lower priority pods. Pod preemption allows higher priority pods to preempt lower priority pods if there are insufficient resources available. This ensures that critical applications are always running, even during periods of high resource contention.

Here are some additional best practices:

  • Regularly review and adjust resource requests and limits based on actual usage.
  • Use Horizontal Pod Autoscaling (HPA) to automatically scale the number of pods based on resource utilization.
  • Monitor resource utilization across namespaces to identify potential imbalances.
  • Implement pod affinity and anti-affinity to control pod placement and ensure optimal resource utilization.

FAQ: Kubernetes Pod Resource Utilization

**What is the difference between resource requests and limits?**
Resource requests specify the minimum amount of resources a pod needs to run, while resource limits specify the maximum amount of resources a pod can consume. [Understanding these values](https://courthousezoological.com/n7sqp6kh?key=e6dd02bc5dbf461b97a9da08df84d31c) is crucial for resource management.
**How do I check resource utilization for all pods in a namespace?**
Use the command kubectl top pod -n to view the CPU and memory usage for all pods in a specific namespace.
**What happens if a pod exceeds its resource limit?**
If a pod exceeds its memory limit, it may be terminated by the Kubernetes OOM killer. If a pod exceeds its CPU limit, it will be throttled, which can negatively impact its performance.
**Why is my pod using more memory than requested?**
The request value is a guarantee of minimum resources, while the pod can use more resources up to the limit value if available.
**How can I set up alerts for high resource utilization?**
You can use Prometheus and Grafana to set up alerts based on resource utilization metrics. Configure Prometheus to monitor the desired metrics and set up alert rules in Grafana to notify you when metrics exceed predefined thresholds. You can also use cloud provider-specific monitoring services, which typically offer built-in alerting capabilities.
Regularly checking and optimizing Kubernetes pod CPU and memory utilization is not just a task; it **Question & Answer :** I am trying to see how much memory and CPU is utilized by a kubernetes pod. I ran the following command for this: 
kubectl top pod podname --namespace=default

I am getting the following error:

W0205 15:14:47.248366 2767 top_pod.go:190] Metrics not available for pod default/podname, age: 190h57m1.248339485s error: Metrics not available for pod default/podname, age: 190h57m1.248339485s
  1. What do I do about this error? Is there any other way to get CPU and memory usage of the pod?
  2. I saw the sample output of this command which shows CPU as 250m. How is this to be interpreted?
  3. Do we get the same output if we enter the pod and run the linux top command?

CHECK WITHOUT METRICS SERVER or ANY THIRD PARTY TOOL

If you want to check pods cpu/memory usage without installing any third party tool then you can get memory and cpu usage of pod from cgroup.

  1. Go to pod’s exec mode kubectl exec -it pod_name -n namespace -- /bin/bash
  2. Run cat /sys/fs/cgroup/cpu/cpuacct.usage for cpu usage
  3. Run cat /sys/fs/cgroup/memory/memory.usage_in_bytes for memory usage

Make Sure you have added the resources section (requests and limits) to deployment so that it can calculate the usage based on cgroup and container will respect the limits set on pod level

NOTE: This usage is in bytes. This can vary upon pod usage and these values changes frequently.