You are currently viewing How to Fix the “Kubernetes OOM Killed” Error

How to Fix the “Kubernetes OOM Killed” Error

Kubernetes is an open-source container orchestration platform for scheduling and automating the deployment, management, and scaling of containerized applications. However, sometimes users face one of the most common error called “OOM Killed Error” .

In this blog, we will look at the causes of the OOM Killed Kubernetes error and present thorough solutions to ensure that your applications function smoothly on Kubernetes.

What is the OOM Killed Kubernetes Error (Exit Code 137)?

OOM Killed stands for “out of memory killed,”  and it is represented by Exit Code 137, which indicates that the Linux kernel has terminated a container due to exceeding its allocated memory limit. When a container is terminated due to an OOM condition, Kubernetes considers it OOM Killed, and the exit code 137 is logged for troubleshooting. 

In Kubernetes, each container within a pod can specify two memory-related parameters:  The memory limit and the memory request. The memory limit represents the maximum amount of RAM a container can use before it is forcefully terminated. On the other hand, the memory request is the minimum amount of memory that Kubernetes guarantees for the container’s operation.

How does the OOM Killer Mechanism work?

The OOM Killer is the mechanism in the Linux kernel that prevents the system from running out of memory. It prohibits the system from consuming too much memory. When the system faces the memory shortage issue, the kernel uses the OOM Killer to select a process to terminate to clear up memory and keep the system functioning. 

The OOM Killer operates by identifying the process that consumes the most memory but is also deemed to be the least important to the system’s functionality. This selection procedure is dependent on several parameters, including the process’s memory utilization, priority level, and time in operation. 

After identifying the process to kill by OOM Killer, it sends a signal to process, and direct to terminate it. If the process does not respond to the signal, the kernel forcefully terminates the process and free up the memory.

What are the common reasons for the error?

1. Insufficient memory limit

One of the most common reasons is a misconfigured memory limit. If the defined limits are too low, the container will exceed them under normal workload conditions. it’s necessary to understand the application’s requirements and to monitor it under different load scenarios. So, it’s important to define the appropriate memory limits.

2. Memory leaks in applications

The second reason is memory leaks in applications. A memory leak happens when a program uses memory but does not return it to the system once it has finished using it. Over time, this can cause a rise in the application’s memory utilisation, finally resulting in an OOM Killed event.

3. Resources overcommitment

Kubernetes allows for resource overcommitment, which can result in several containers exceeding the node’s physical memory capacity.

4. Node memory pressure

When a node in a Kubernetes cluster experiences memory pressure, it indicates that the node’s available memory is low. This can happen if too many pods are scheduled on a single node or if the pods running on the node use more RAM than expected.

OMM Killed (Exit Code 137) diagnosis

  1. Monitor memory uses
  2. Check the pod logs 
  3. Use a memory profiler

How to fix OOM Killed kubernetes error

1. Set appropriate memory requests and limits

The first step is to correctly configure memory requests and limits in your Kubernetes manifest.

Requests: the minimum amount of memory guaranteed to the container.

Limits: the maximum amount of memory the container can use.

Monitor application performance and set a memory limit according to that. Use tools like Kubernetes Metrics Server to gather resource usage data.

2. Check and analyze memory usage

  • Observe memory usage and trends. 
  • Check memory leaks and observe patterns. 
  • Use profiling tools like Heapster to diagnose memory issues.

3. Application code optimization

  • Optimize data structures and algorithms to make better use of memory.
  • Fix memory leaks in the application
  • Analyzing the application task may be quite challenging. However, a number of tools can be useful, including memory analyzers, profiling tools, and even straightforward log statements for monitoring memory utilization.

4. Use Horizontal Pod Autoscaling (HPA)

Horizontal Pod Autoscaling automatically adjusts the number of pod replicas based on resource usage metrics.

How to set up HPA:

i) Ensure Metrics Server is running in your cluster.

ii) Define an HPA resource in your Kubernetes manifest.

5. Utilize Node Affinity and Taints

Node affinity ensures that pods are scheduled on nodes that meet specific criteria. Taints prevent pods from being scheduled on specific nodes unless they have a matching toleration.

6. Regularly updating Kubernetes and applications

  • Update Kubernetes frequently to take advantage of bug fixes and performance enhancements.
  • Use security patches to defend against vulnerabilities that are known to exist.
  • Automate application updates and deployments with a CI/CD pipeline.

Choose Supportfly Kubernetes Consulting Services

If you are looking to leverage Kubernetes to improve your container orchestration and optimize your cloud-native applications our Kubernetes consulting services are here to help you achieve your goals efficiently and effectively.

  • Our Kubernetes certified expert team ensures that we can handle any Kubernetes issue, from cluster management to application development and security.
  • Every organization has unique requirements. Our consulting services are customized to fulfil your specific requirements, whether you are just starting with Kubernetes or looking to optimize an existing setup.
  • From initial planning and design to deployment and management, we provide comprehensive support throughout your Kubernetes infrastructure. 


The OOM Killed error is a common problem in Kubernetes, but with the right precaution and strategy, it can be managed and fixed. Setting proper memory requests and limitations, monitoring and analyzing memory usage, optimizing application memory consumption, and employing Kubernetes capabilities such as resource quotas, autoscaling, and node affinity will help guarantee that your applications run consistently and efficiently.

By implementing these best practices in your Kubernetes environment, you can minimize OOMKilled errors, improve application performance, and enhance the overall stability of your containerized workloads. Regularly review and adjust your resource configurations based on usage patterns and evolving application requirements to maintain a healthy and resilient Kubernetes cluster.


Q1. What does it mean by Exit Code 137?

A  137 exit code in kubernetes indicates that a process was forcibly terminated.

Q2. How can I check which POD was OOMKilled?

You can use a specific command to check which pod is having an error.

Q3. What tools can I use to detect memory leaks in an application?

Tools like Valgrind, built-in- language profilers and memory profiling tools specific to your programming language can help detect memory leaks.