Checking Kubernetes pod CPU and memory utilization - kubernetes

To check Kubernetes pod CPU and memory usage, we can use different tools and commands. These tools give us real-time data about how much resources we are using. With the kubectl command-line tool, we can easily see how much CPU and memory our pods are using. This helps us manage and optimize resources in our Kubernetes setup. By monitoring this, we can make sure our applications run well without using too many resources. Using too many resources can cause performance problems.

In this article, we will look at different ways to monitor CPU and memory usage of Kubernetes pods. We will talk about using kubectl commands for quick checks. We will also learn how to set up the Metrics Server for ongoing monitoring. We will see how to analyze resource usage with Prometheus and how to show metrics with Grafana. Plus, we will discuss custom metrics and answer common questions to help us understand Kubernetes resource management better.

Checking Kubernetes Pod CPU and Memory Utilization - Kubernetes?
How to Use kubectl to Check Kubernetes Pod Resource Utilization?
Monitoring Kubernetes Pod CPU and Memory with Metrics Server?
Analyzing Resource Usage with Prometheus in Kubernetes?
Visualizing Kubernetes Pod Resource Utilization with Grafana?
Using Custom Metrics for Kubernetes Pod CPU and Memory Monitoring?
Frequently Asked Questions.

For more info on Kubernetes, we can look at articles like What is Kubernetes and How Does it Simplify Container Management? and How Do I Monitor My Kubernetes Cluster? for more understanding and real-life uses.

How to Use kubectl to Check Kubernetes Pod Resource Utilization?

To check how much CPU and memory Kubernetes pods are using, we can use the kubectl command-line tool. Below are some commands that will help us get this information quickly.

Check Pod Resource Requests and Limits

We can see the resource requests and limits for each pod by using this command:

kubectl get pods <pod-name> -o=jsonpath='{.spec.containers[*].resources}'

Just change <pod-name> to the name of your pod. This command will show us the CPU and memory requests and limits that are set in the pod’s settings.

Get Current Resource Usage

To get the current CPU and memory usage for all pods, we can use this command:

kubectl top pods

Make sure the Metrics Server is running in our cluster. This command gives us real-time information about resource usage.

Check Resource Usage for a Specific Pod

If we want to check the resource usage for a specific pod, we can run:

kubectl top pod <pod-name>

This will show us the current CPU and memory usage for that pod.

Get Detailed Pod Information

For more details about a pod’s settings, including resource limits, we can use this command:

kubectl describe pod <pod-name>

This command gives us a lot of information. We can see events, resource requests, limits, and more.

Example: Listing All Pods with Resource Usage

To see all pods along with their resource usage, we can run:

kubectl get pods --sort-by=.spec.containers[0].resources.requests.cpu

This command sorts the pods by their CPU requests. It helps us spot which pods are using more resources.

For better monitoring and managing Kubernetes resources, we can think about using tools like Metrics Server and Prometheus.

Monitoring Kubernetes Pod CPU and Memory with Metrics Server

To monitor CPU and memory usage of Kubernetes pods, we need the Metrics Server. This tool collects resource data from Kubelets and shows it through the Kubernetes API. It helps us get CPU and memory info for pods and nodes in our cluster.

Installing Metrics Server

To install the Metrics Server, we can use this command:

kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

Verifying Installation

After we install it, we should check if the Metrics Server is running well:

kubectl get deployment metrics-server -n kube-system

Checking Pod Metrics

To see the CPU and memory usage of all pods in a specific namespace, we can run this command:

kubectl top pods -n <namespace>

For example, to check metrics in the default namespace:

kubectl top pods -n default

Output Example

The output will show us the pod name, CPU usage, and memory usage:

NAME             CPU(cores)   MEMORY(bytes)
my-app-abc-xyz  250m         512Mi
my-app-def-uvw  300m         256Mi

Checking Node Metrics

We can also check resource usage for nodes by running:

kubectl top nodes

This command gives us a view of CPU and memory usage for each node in the cluster.

Customizing Metrics Collection

We can change the Metrics Server by updating its deployment settings. For example, we can set the resource requests and limits in the metrics-server deployment YAML:

spec:
  containers:
  - name: metrics-server
    resources:
      requests:
        cpu: 100m
        memory: 200Mi
      limits:
        cpu: 200m
        memory: 400Mi

Troubleshooting Metrics Server

If we have problems with Metrics Server not giving metrics, we should check:

The Metrics Server is running with no errors.
Kubelet is set up to allow metrics collection.
The API aggregation layer is on in our Kubernetes cluster.

For more details about monitoring Kubernetes, we can look at how do I monitor my Kubernetes cluster.

Analyzing Resource Usage with Prometheus in Kubernetes

To analyze resource usage in Kubernetes with Prometheus, we need to set up Prometheus to get metrics from our Kubernetes cluster. Here are the steps we should follow:

Install Prometheus: We can use Helm to install Prometheus in our Kubernetes cluster.

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install prometheus prometheus-community/prometheus

Configure Prometheus to Scrape Metrics: We must ensure that Prometheus is ready to scrape metrics from our pods. We can change the prometheus.yml file to add this scrape config for Kubernetes:

scrape_configs:
  - job_name: 'kubernetes-pods'
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_namespace]
        action: keep
        regex: default|kube-system

Access Prometheus Dashboard: After we deploy, we can access the Prometheus UI to see metrics. We can port-forward the service like this:
```
kubectl port-forward svc/prometheus-server 9090:80
```
Then, we go to http://localhost:9090 in our web browser.
Query Metrics: We can use Prometheus queries to check CPU and memory usage. Here are some example queries:
- To check CPU usage of pods:
```
sum(rate(container_cpu_usage_seconds_total{image!=""}[5m])) by (pod)
```
- To check memory usage of pods:
```
sum(container_memory_usage_bytes{image!=""}) by (pod)
```

Set Up Alerts: We can create alerts based on these usage metrics. We can make an alerting rule like this:

groups:
- name: kubernetes-resources
  rules:
  - alert: HighCpuUsage
    expr: sum(rate(container_cpu_usage_seconds_total{image!=""}[5m])) by (pod) > 0.8
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "High CPU usage detected on pod {{ $labels.pod }}"

This setup helps us to monitor and analyze resource usage in Kubernetes with Prometheus. For more details about monitoring Kubernetes clusters, we can check this guide.

Visualizing Kubernetes Pod Resource Utilization with Grafana

Grafana is a great tool for showing data. It works well with Kubernetes. It helps us see how much resources our pods use. To see CPU and memory usage of Kubernetes pods with Grafana, we can follow these steps:

Set Up Prometheus: First, we need to install Prometheus in our Kubernetes cluster. Prometheus will collect metrics from our Kubernetes nodes and pods.

kubectl create namespace monitoring
kubectl apply -f https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/master/bundle.yaml

Install Grafana: We can set up Grafana in our Kubernetes cluster. We can use Helm or YAML files.

Using Helm:

helm repo add grafana https://grafana.github.io/helm-charts
helm install grafana grafana/grafana --namespace monitoring

Using YAML:

kubectl apply -f https://raw.githubusercontent.com/grafana/helm-charts/main/charts/grafana/templates/deployment.yaml

Configure Data Source in Grafana: After we install Grafana, we should log in (the default username is admin and password is prom-operator). Then we need to add Prometheus as a data source:
- Go to Configuration > Data Sources > Add data source.
- Choose Prometheus and put the URL (it is usually http://prometheus-operated.monitoring.svc.cluster.local:9090).
Create a Dashboard:
- Click on Dashboards > New Dashboard.
- Add a new Panel.
- Use these Prometheus queries to see CPU and memory usage:
  - CPU Utilization:
```
sum(rate(container_cpu_usage_seconds_total{image!=""}[5m])) by (pod)
```
  - Memory Utilization:
```
sum(container_memory_usage_bytes{image!=""}) by (pod)
```
Customize Visualization:
- Pick the type of visualization (like Graph or Gauge) that you like.
- Set thresholds and labels to help understand the data better.
Deploy and View:
- Save the dashboard and take a look at it.
- We can now watch the resource usage of our Kubernetes pods in real-time.

For more details on how to deploy apps with monitoring in Kubernetes, we can check this article on monitoring Kubernetes applications with Prometheus and Grafana.

Using Custom Metrics for Kubernetes Pod CPU and Memory Monitoring?

Custom metrics in Kubernetes help us monitor and optimize how we use resources. This is especially true for CPU and memory usage in pods. By using the Kubernetes API and custom metrics, we can set specific metrics that fit our applications.

Setting Up Custom Metrics

Install Metrics Server: First, we need to have the Metrics Server running in our cluster. This server gives us important resource metrics.
```
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
```
Define Custom Metrics: We use the Kubernetes API to show custom metrics. We can create our metrics with any good monitoring tool or library. Prometheus is a common choice.

Expose Metrics: We need to change our application to show metrics in a way that Prometheus can read. Usually, we do this at an HTTP endpoint.

from prometheus_client import start_http_server, Summary

# Create a metric to track CPU usage
cpu_usage = Summary('cpu_usage', 'CPU usage of the application')

@cpu_usage.time()
def process_request():
    # Our code logic here
    pass

if __name__ == '__main__':
    start_http_server(8000)
    while True:
        process_request()

Configuring Horizontal Pod Autoscaler (HPA) with Custom Metrics

To use custom metrics for autoscaling, we configure the Horizontal Pod Autoscaler (HPA) with the custom metrics API.

Install the Custom Metrics Adapter: If we use Prometheus, we might need to install the Prometheus Adapter.
```
helm install prometheus-adapter prometheus-community/prometheus-adapter
```

Define HPA with Custom Metrics: We create an HPA resource that uses our custom metrics.

apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: my-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Pods
    pods:
      metric:
        name: cpu_usage
      target:
        type: AverageValue
        averageValue: 100m

Apply the HPA: We deploy the HPA setup using kubectl.
```
kubectl apply -f hpa.yaml
```

Monitor and Validate

Check HPA Status: We need to make sure the HPA is working right.
```
kubectl get hpa
```

Inspect Pod Metrics: We check that our custom metrics are collected correctly.

kubectl get --raw "/apis/custom.metrics.k8s.io/v1beta1/namespaces/default/pods/my-app/cpu_usage"

By using custom metrics in Kubernetes, we can monitor CPU and memory use based on our application needs. This helps us manage and optimize resources better with autoscaling. For more information on Kubernetes monitoring, we can look at this article on monitoring a Kubernetes application with Prometheus and Grafana.

Frequently Asked Questions

1. How can we check the CPU and memory usage of a Kubernetes pod?

To check the CPU and memory of a Kubernetes pod, we can use the kubectl top pod command. This command shows the current usage of resources for all pods in our namespace. Just run kubectl top pod to see the CPU and memory numbers. We must make sure that the Metrics Server is installed in our cluster to get correct readings.

2. What is the role of Metrics Server in Kubernetes?

The Metrics Server is important for checking resources in Kubernetes. It collects data from Kubelets and shares it using the Kubernetes API. This helps us use commands like kubectl top to see how much resources pods and nodes are using. It is also needed for Horizontal Pod Autoscaling because it gives the needed data for scaling decisions.

3. Can we visualize Kubernetes pod resource usage with Grafana?

Yes, we can use Grafana to visualize resource usage of Kubernetes pods. By connecting Prometheus with Grafana, we can make dashboards that show real-time data about our pods, including CPU and memory use. This setup makes monitoring and analyzing easier. It helps us use resources better in our Kubernetes clusters.

4. How do we set resource requests and limits for a Kubernetes pod?

We can set resource requests and limits for a Kubernetes pod by adding them in the pod’s YAML file. Under the containers part, we add resources with requests and limits for CPU and memory. Here is an example:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: my-container
    image: my-image
    resources:
      requests:
        memory: "64Mi"
        cpu: "250m"
      limits:
        memory: "128Mi"
        cpu: "500m"

This setup makes sure the pod has guaranteed resources while also setting upper limits.

5. What tools can we use for advanced monitoring of Kubernetes pods?

For better monitoring of Kubernetes pods, tools like Prometheus and Grafana are good choices. Prometheus collects and saves metrics, while Grafana gives us a way to visualize data. Other tools like Datadog and New Relic can also help us monitor everything well. These tools help us keep track of CPU and memory usage, making resource management better in our Kubernetes environment.

For more information about Kubernetes and its features, we can check articles like what are Kubernetes pods and how do I work with them or how do I monitor my Kubernetes cluster.