# CloudWatch alarm: EKS pod_cpu_utilization_over_pod_limit

CloudWatch alarms · Updated 16 November 2026

**Short answer:** Alarm on ContainerInsights pod_cpu_utilization_over_pod_limit per ClusterName, Namespace and Service using the Maximum over 60 seconds, firing when it is above 80 for 5 of 5 minutes. It tells you a pod behind a Kubernetes Service has been using more than 80% of its CPU limit for five minutes, the point where throttling starts to add latency.

## What the metric measures

`pod_cpu_utilization_over_pod_limit` compares a pod's CPU use with the CPU limit set on its containers, as a percentage. Container Insights publishes it in `ContainerInsights`. The dimensions in this alarm group pods by the Kubernetes `Service` that selects them, inside a `Namespace`, and the `Maximum` statistic means the busiest pod in the group decides.

Two prerequisites are easy to miss:

- **The containers need CPU limits.** Without a limit there is nothing to divide by, and the metric is not reported for that pod.
- **The pods need a Service.** Workers, jobs and anything else not selected by a Kubernetes Service do not appear under the `Service` dimension; alarm on them using the pod-name dimensions instead.

Reaching the limit does not kill anything. The kernel throttles the container, letting it use its share of CPU time in each scheduling period and then pausing it until the next one. The visible symptom is slower responses and timeouts, often with node CPU looking perfectly healthy.

## Recommended alarm settings

| Setting | Recommended value |
|---|---|
| Namespace | `ContainerInsights` |
| Metric | `pod_cpu_utilization_over_pod_limit` |
| Dimensions | ClusterName, Namespace, Service |
| Statistic | Maximum |
| Threshold | 80 |
| Period | 60 seconds |
| Datapoints to alarm | 5 |
| Evaluation periods | 5 |
| Comparison operator | `GreaterThanThreshold` |

## Tuning and interpretation

Keep the threshold at 80 or lower. Throttling is measured in very short intervals, so a pod averaging 80% over a minute has almost certainly been throttled during bursts within it. For request-serving services where tail latency matters, 70 is a sensible tighter setting.

Read the alarm alongside the Horizontal Pod Autoscaler if you use one. The HPA's CPU target is a percentage of the pod's **request**, while this metric is a percentage of its **limit**. A pod with a 250m request and a 1000m limit hits a 70% HPA target at 175m, long before this alarm sees 80% of the limit (800m). If this alarm fires anyway, the HPA is either at its maximum replicas or not scaling on CPU at all.

Pods that legitimately run hot, such as batch jobs that should use all the CPU they are given, deserve their own alarm or none, rather than a higher threshold for the whole namespace.

## Create the alarm

```
aws cloudwatch put-metric-alarm \
  --alarm-name eks-prod-checkout-pod-cpu-near-limit \
  --alarm-description "A checkout pod above 80% of its CPU limit for 5 minutes" \
  --namespace ContainerInsights \
  --metric-name pod_cpu_utilization_over_pod_limit \
  --dimensions Name=ClusterName,Value=prod Name=Namespace,Value=shop \
      Name=Service,Value=checkout \
  --statistic Maximum \
  --period 60 \
  --evaluation-periods 5 \
  --datapoints-to-alarm 5 \
  --threshold 80 \
  --comparison-operator GreaterThanThreshold \
  --alarm-actions arn:aws:sns:eu-west-2:123456789012:oncall-alerts
```

## When it fires

1. **See which pods are hot** and what they are allowed:

   ```
   kubectl top pods -n shop -l app=checkout
   kubectl get pods -n shop -l app=checkout \
     -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.containers[*].resources.limits.cpu}{"\n"}{end}'
   ```

2. **One pod or all of them?** One hot pod often means uneven load balancing or a single expensive request type. All of them means the service needs more capacity.

3. **More capacity:** add replicas (or raise the HPA maximum) when the work can be spread; raise the CPU limit when single requests are CPU-bound and need more headroom.

4. **Check whether it is new.** A jump right after a deploy points at a code change: a hot loop, heavier serialisation, or a retry storm against a failing dependency.

Raising the limit without raising the request lets the pod burst further but does not reserve the CPU, so on a busy node it may still be starved. Check [node CPU](https://cloudconsole.dev/alarms/eks-insights-node-cpu-utilization) before you rely on it.

## Questions

### Does a pod get killed when it exceeds its CPU limit?

No. CPU is throttled, not enforced by killing. The pod keeps running, only slower; memory limits are the ones that end in a kill.

### Why is pod_cpu_utilization_over_pod_limit missing for some pods?

The pod's containers have no CPU limit, or the pod is not selected by a Kubernetes Service so it does not appear under the Service dimension.

## When this happens away from your desk

CPU throttling shows up as slowness rather than errors, so it is easy to dismiss from a phone notification alone. CloudConsole, a phone app for AWS, is built to show this alarm with the service's other metrics on one screen.

[About the CloudConsole app](https://cloudconsole.dev/aws-console-app) · [Download on the App Store](https://apps.apple.com/app/cloudconsole-for-aws/id6835419710)

## Sources

- [Recommended alarms (Amazon CloudWatch User Guide)](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Best_Practice_Recommended_Alarms_AWS_Services.html)
- [Amazon EKS and Kubernetes Container Insights metrics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Container-Insights-metrics-EKS.html)

## Related

- [CloudWatch alarm: EKS pod_memory_utilization_over_pod_limit](https://cloudconsole.dev/alarms/eks-insights-pod-memory-utilization-over-pod-limit)
- [CloudWatch alarm: EKS node_cpu_utilization](https://cloudconsole.dev/alarms/eks-insights-node-cpu-utilization)
- [CloudWatch alarm: EKS node_memory_utilization](https://cloudconsole.dev/alarms/eks-insights-node-memory-utilization)
- [How to create a CloudWatch alarm for CPU utilization](https://cloudconsole.dev/how-to/create-cloudwatch-cpu-alarm)
- [aws cloudwatch put-metric-alarm](https://cloudconsole.dev/cli/cloudwatch-put-metric-alarm)
- [CloudWatch alarm: EKS node_filesystem_utilization](https://cloudconsole.dev/alarms/eks-insights-node-filesystem-utilization)

---

Source: https://cloudconsole.dev/alarms/eks-insights-pod-cpu-utilization-over-pod-limit

CloudConsole is an independent iPhone and Android app for Amazon Web Services by Cloudconcur Ltd. It is not affiliated with Amazon Web Services.
