# Manage Pod Resources in Kubernetes > For the complete documentation index, see [llms.txt](https://docs.redpanda.com/llms.txt). Component-specific: [streaming-full.txt](https://docs.redpanda.com/streaming-full.txt) --- title: Manage Pod Resources in Kubernetes latest-redpanda-tag: v24.3.9 latest-console-tag: v3.7.3 latest-operator-version: v26.1.4 # EOL = End-of-Life (support lifecycle status) page-is-nearing-eol: "false" page-is-past-eol: "true" page-eol-date: December 3, 2025 latest-connect-version: 4.93.0 docname: kubernetes/k-manage-resources page-component-name: streaming page-version: "24.3" page-component-version: "24.3" page-component-title: Streaming page-relative-src-path: kubernetes/k-manage-resources.adoc page-edit-url: https://github.com/redpanda-data/docs/edit/v/24.3/modules/manage/pages/kubernetes/k-manage-resources.adoc description: Configure your Pod resources such as memory, CPU, and storage. page-git-created-date: "2024-01-04" page-git-modified-date: "2025-02-07" support-status: past end-of-life --- Managing Pod resources, such as CPU, memory, and storage, is critical for ensuring that your Redpanda cluster runs well in Kubernetes. In this guide, you’ll learn how to define and configure resource requests and limits using the Redpanda Helm chart and Redpanda CRD. Setting these values before deployment helps guarantee predictable scheduling, enforces the Guaranteed QoS classification, and minimizes the risk of performance issues such as resource contention or unexpected evictions. ## [](#prerequisites)Prerequisites - See [Kubernetes Cluster Requirements and Recommendations](https://docs.redpanda.com/streaming/24.3/deploy/deployment-option/self-hosted/kubernetes/k-requirements/) for the minimum worker node, memory, CPU, and storage requirements. - Make sure that your physical or virtual machines have enough resources to give to Redpanda. To see the available resources on the worker nodes that you have provisioned: ```bash kubectl describe nodes ``` ## [](#production-considerations)Production considerations - [Enable the `Guaranteed` quality of service class for Pods that run Redpanda](#qos). This setup ensures that the CPU and memory allocated to Redpanda are not subject to throttling or other contention issues, providing a stable and predictable performance environment. - [Enable memory locking](#memory). This configuration prevents the operating system from paging out Redpanda’s memory to disk, which can significantly impact performance. - Ensure you [give each Redpanda broker at least 4 CPU cores](#cpu). This configuration ensures that Redpanda has enough CPU resources to run efficiently. - Ensure you [give Redpanda at least 2 Gi of memory](#memory) per core. This configuration ensures that Redpanda has enough memory to run efficiently. - Ensure that the number of CPU cores you allocate to Redpanda is an even integer. This configuration allows Redpanda to leverage the [static CPU manager policy](https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/#static-policy-configuration), granting the Pod exclusive access to the requested cores for optimal performance. ## [](#memory)Configure memory resources When deploying Redpanda, you must reserve sufficient memory for both Redpanda and other system processes. Redpanda uses the Seastar framework to manage memory through two important flags. In Kubernetes, the values of these flags are usually set for you, depending on how you configure the Redpanda CRD or the Helm chart. - **`--memory`**: When set, explicitly defines the Redpanda heap size. - **`--reserve-memory`**: When set, reserves a specific amount of memory for system overhead. If not set, a reserve is automatically calculated. Learn more about these Seastar flags | | --memory Not set | --memory Set (M) | | --- | --- | --- | | --reserve-memory Not set | Heap size = available memory - calculated reserve | Heap size = exactly M (if M plus calculated reserve ≤ available memory). Otherwise, startup fails | | --reserve-memory set (R) | Heap size = available memory - R | Heap size = exactly M (if M + R ≤ available memory). Otherwise, startup fails | Definitions and behavior: - **Available memory**: The memory remaining after subtracting system requirements, such as `/proc/sys/vm/min_free_kbytes`, from the total or cgroup-limited memory. - **Calculated reserve**: The greater of 1.5 GiB or 7% of _available memory_ used when `--reserve-memory` is not explicitly set. These flags are set for you by default when using the Redpanda Helm chart or Operator. However, you can manually set these flags using the `statefulset.additionalRedpandaCmdFlags` configuration if needed. > ⚠️ **CAUTION** > > Avoid manually setting the `--memory` and `--reserve-memory` flags unless absolutely necessary. Incorrect settings can lead to performance issues, instability, or data loss. > 📝 **NOTE** > > This option is deprecated and maintained only for backward compatibility. ### Helm + Operator `redpanda-cluster.yaml` ```yaml apiVersion: cluster.redpanda.com/v1alpha2 kind: Redpanda metadata: name: redpanda spec: chartRef: {} clusterSpec: statefulset: additionalRedpandaCmdFlags: - '--lock-memory' (1) resources: requests: memory: (2) limits: memory: (3) ``` ```bash kubectl apply -f redpanda-cluster.yaml --namespace ``` ### Helm #### --values `memory.yaml` ```yaml statefulset: additionalRedpandaCmdFlags: - '--lock-memory' (1) resources: requests: memory: (2) limits: memory: (3) ``` ```bash helm upgrade --install redpanda redpanda/redpanda --namespace --create-namespace \ --values memory.yaml --reuse-values ``` #### --set ```bash helm upgrade --install redpanda redpanda/redpanda --namespace --create-namespace \ --set statefulset.additionalRedpandaCmdFlags=="{--lock-memory}" \ (1) --set resources.requests.memory= \ (2) --set resources.limits.memory= (3) ``` | 1 | Enable memory locking to prevent the operating system from paging out Redpanda’s memory to disk. This can significantly improve performance by ensuring Redpanda has uninterrupted access to its allocated memory. | | --- | --- | | 2 | Request at least 2.22 Gi of memory per core to ensure Redpanda has the 2 Gi per core it requires after accounting for the 90% allocation to the --memory flag.Redpanda supports the following memory resource units: B, K, M, G, Ki, Mi, and Gi.Memory units are truncated to the nearest whole MiB. For example, a memory request of 1024 KiB will result in 1 MiB being allocated. For a description of memory resource units, see the Kubernetes documentation. | | 3 | Set the memory limit to match the memory request. This ensures Kubernetes enforces a strict upper bound on memory usage and helps maintain the Guaranteed QoS classification. | When the StatefulSet is deployed, make sure that the memory request and limit are set: ```bash kubectl --namespace= get pod -o jsonpath='{.spec.containers[?(@.name=="redpanda")].resources}{"\n"}' ``` ## [](#cpu)Configure CPU resources Redpanda uses the Seastar framework to manage CPU usage through the `--smp` flag, which sets the number of CPU cores available to Redpanda. This is configured using `resources.cpu.cores`, which automatically applies the same value to both `resources.requests.cpu` and `resources.limits.cpu`. | Default Configuration | Production Recommendation | | --- | --- | | resources.cpu.cores: 1 Equivalent to setting resources.requests.cpu and resources.limits.cpu to 1. | Set resources.cpu.cores to 4 or greater.Set CPU cores to an even integer to leverage the static CPU manager policy, granting the Pod exclusive access to the requested cores for optimal performance. | ### Helm + Operator `redpanda-cluster.yaml` ```yaml apiVersion: cluster.redpanda.com/v1alpha2 kind: Redpanda metadata: name: redpanda spec: chartRef: {} clusterSpec: resources: cpu: cores: (1) ``` ```bash kubectl apply -f redpanda-cluster.yaml --namespace ``` ### Helm #### --values `cpu-cores.yaml` ```yaml resources: cpu: cores: (1) ``` ```bash helm upgrade --install redpanda redpanda/redpanda --namespace --create-namespace \ --values cpu-cores.yaml --reuse-values ``` #### --set ```bash helm upgrade --install redpanda redpanda/redpanda --namespace --create-namespace \ --set resources.cpu.cores= \ (1) ``` | 1 | Set resources.cpu.cores to the desired number of CPU cores for Redpanda. This value is applied as both the CPU request and limit, ensuring that the Pod maintains the Guaranteed QoS classification by enforcing a strict upper bound on CPU usage. | | --- | --- | When the StatefulSet is deployed, make sure that the CPU request and limit are set: ```bash kubectl --namespace get pod -o jsonpath='{.spec.containers[?(@.name=="redpanda")].resources}{"\n"}' ``` ## [](#qos)Quality of service and resource guarantees To ensure that Redpanda receives stable and consistent resources, set the [quality of service (QoS) class](https://kubernetes.io/docs/tasks/configure-pod-container/quality-service-pod/#create-a-pod-that-gets-assigned-a-qos-class-of-guaranteed) to `Guaranteed` by matching resource requests and limits on all containers in the Pods that run Redpanda. Kubernetes uses QoS to decide which Pods to evict from a worker node that runs out of resources. When a worker node runs out of resources, Kubernetes evicts Pods with a `Guaranteed` QoS last. This stability is crucial for Redpanda because it requires consistent computational and memory resources to maintain high performance. Kubernetes gives a Pod a `Guaranteed` QoS class when every container inside it has identical resource requests and limits set for both CPU and memory. This strict configuration signals to Kubernetes that these resources are critical and should not be throttled or reclaimed under normal operating conditions. To configure the Pods that run Redpanda with `Guaranteed` QoS, specify both resource requests and limits for all _enabled_ containers in the Pods. For example: ### Helm + Operator `redpanda-cluster.yaml` ```yaml apiVersion: cluster.redpanda.com/v1alpha2 kind: Redpanda metadata: name: redpanda spec: chartRef: {} clusterSpec: resources: cpu: cores: requests: memory: limits: memory: # Matches the request statefulset: sideCars: configWatcher: resources: requests: cpu: memory: limits: cpu: # Matches the request memory: # Matches the request initContainers: tuning: resources: requests: cpu: memory: limits: cpu: # Matches the request memory: # Matches the request setTieredStorageCacheDirOwnership: resources: requests: cpu: memory: limits: cpu: # Matches the request memory: # Matches the request configurator: resources: requests: cpu: memory: limits: cpu: # Matches the request memory: # Matches the request ``` ```bash kubectl apply -f redpanda-cluster.yaml --namespace ``` ### Helm #### --values `memory.yaml` ```yaml resources: cpu: cores: requests: memory: limits: memory: # Matches the request statefulset: sideCars: configWatcher: resources: requests: cpu: memory: limits: cpu: # Matches the request memory: # Matches the request initContainers: tuning: resources: requests: cpu: memory: limits: cpu: # Matches the request memory: # Matches the request setTieredStorageCacheDirOwnership: resources: requests: cpu: memory: limits: cpu: # Matches the request memory: # Matches the request configurator: resources: requests: cpu: memory: limits: cpu: # Matches the request memory: # Matches the request ``` ```bash helm upgrade --install redpanda redpanda/redpanda --namespace --create-namespace \ --values memory.yaml --reuse-values ``` #### --set ```bash helm upgrade --install redpanda redpanda/redpanda --namespace --create-namespace \ --set resources.cpu.cores= \ --set resources.requests.memory= \ --set resources.limits.memory= \ --set statefulset.sideCars.configWatcher.resources.requests.cpu= \ --set statefulset.sideCars.configWatcher.resources.requests.memory= \ --set statefulset.sideCars.configWatcher.resources.limits.cpu= \ --set statefulset.sideCars.configWatcher.resources.limits.memory= \ --set statefulset.initContainers.tuning.resources.requests.cpu= \ --set statefulset.initContainers.tuning.resources.requests.memory= \ --set statefulset.initContainers.tuning.resources.limits.cpu= \ --set statefulset.initContainers.tuning.resources.limits.memory= \ --set statefulset.initContainers.setTieredStorageCacheDirOwnership.resources.requests.cpu= \ --set statefulset.initContainers.setTieredStorageCacheDirOwnership.resources.requests.memory= \ --set statefulset.initContainers.setTieredStorageCacheDirOwnership.resources.limits.cpu= \ --set statefulset.initContainers.setTieredStorageCacheDirOwnership.resources.limits.memory= \ --set statefulset.initContainers.configurator.resources.requests.cpu= \ --set statefulset.initContainers.configurator.resources.requests.memory= \ --set statefulset.initContainers.configurator.resources.limits.cpu= \ --set statefulset.initContainers.configurator.resources.limits.memory= ``` When the StatefulSet is deployed, make sure that the QoS for the Pods is set to `Guaranteed`: ```bash kubectl --namespace= get pod -o jsonpath='{ .status.qosClass}{"\n"}' ``` ## [](#configure-storage-capacity)Configure storage capacity Make sure to provision enough disk storage for your streaming workloads. If you use PersistentVolumes, you can set the storage capacity for each volume. For instructions, see [Configure Storage for the Redpanda data directory in Kubernetes](https://docs.redpanda.com/streaming/24.3/manage/kubernetes/storage/k-configure-storage/). ## [](#pinning)Run Redpanda in shared environments If Redpanda runs in a shared environment, where multiple applications run on the same worker node, you can make Redpanda less aggressive in CPU usage by enabling overprovisioning. This adjustment ensures a fairer distribution of CPU time among all processes, improving overall system efficiency at the cost of Redpanda’s performance. You can enable overprovisioning by either setting the CPU request to a fractional value less than 1 or enabling the `--overprovisioned` flag. > 📝 **NOTE** > > You cannot enable overprovisioning using `resources.cpu.overprovisioned` when both `resources.requests` and `resources.limits` are set. When both of these configurations are set, the `resources.cpu` parameter (including cores) is ignored. Instead, use the `statefulset.additionalRedpandaCmdFlags` configuration to enable overprovisioning. ### Helm + Operator `redpanda-cluster.yaml` ```yaml apiVersion: cluster.redpanda.com/v1alpha2 kind: Redpanda metadata: name: redpanda spec: chartRef: {} clusterSpec: statefulset: additionalRedpandaCmdFlags: - '--overprovisioned' resources: cpu: cores: ``` ```bash kubectl apply -f redpanda-cluster.yaml --namespace ``` ### Helm #### --values `cpu-cores-overprovisioned.yaml` ```yaml statefulset: additionalRedpandaCmdFlags: - '--overprovisioned' resources: cpu: cores: ``` ```bash helm upgrade --install redpanda redpanda/redpanda --namespace --create-namespace \ --values cpu-cores-overprovisioned.yaml --reuse-values ``` #### --set ```bash helm upgrade --install redpanda redpanda/redpanda --namespace --create-namespace \ --set resources.cpu.cores= \ --set statefulset.additionalRedpandaCmdFlags=="{--overprovisioned}" ``` If you’re experimenting with Redpanda in Kubernetes, you can also set the number of CPU cores to millicores to automatically enable overprovisioning. `cpu-cores.yaml` ```yaml resources: cpu: cores: 200m ``` ## [](#suggested-reading)Suggested reading - [Redpanda Helm Specification](https://docs.redpanda.com/streaming/24.3/reference/k-redpanda-helm-spec/#resources) - [Redpanda CRD Reference](https://docs.redpanda.com/streaming/24.3/reference/k-crd/) ## Suggested labs - [Redpanda Iceberg Docker Compose Example](https://docs.redpanda.com/labs/docker-compose/iceberg/) - [Enable Unified Identity with Azure Entra ID for Redpanda and Redpanda Console](https://docs.redpanda.com/labs/docker-compose/oidc/) - [Owl Shop Example Application in Docker](https://docs.redpanda.com/labs/docker-compose/owl-shop/) - [Migrate Data with Redpanda Migrator](https://docs.redpanda.com/labs/docker-compose/redpanda-migrator/) - [Start a Single Redpanda Broker with Redpanda Console in Docker](https://docs.redpanda.com/labs/docker-compose/single-broker/) - [Start a Cluster of Redpanda Brokers with Redpanda Console in Docker](https://docs.redpanda.com/labs/docker-compose/three-brokers/) - [Iceberg Streaming on Kubernetes with Redpanda, MinIO, and Spark](https://docs.redpanda.com/labs/kubernetes/iceberg/) See more [Search all labs](https://docs.redpanda.com/labs)