How to Set Resource Requests in Kubernetes Deployment

To set resource requests in a Kubernetes Deployment, specify the resources.requests field under the container spec in the deployment YAML. This tells Kubernetes the minimum CPU and memory your pod needs to run reliably.

Syntax

Resource requests are defined inside the containers section of a deployment YAML under resources.requests. You specify the minimum CPU and memory your container requires.

Example fields:

• cpu: CPU units requested (e.g., "100m" means 0.1 CPU cores)
• memory: Memory requested (e.g., "256Mi" means 256 mebibytes)

yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: example
  template:
    metadata:
      labels:
        app: example
    spec:
      containers:
      - name: example-container
        image: nginx
        resources:
          requests:
            cpu: "100m"
            memory: "256Mi"

Example

This example shows a deployment with one replica of an Nginx container that requests 200 milliCPU and 512Mi of memory. Kubernetes uses these requests to schedule the pod on a node with enough resources.

yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.23.3
        resources:
          requests:
            cpu: "200m"
            memory: "512Mi"

Output

deployment.apps/nginx-deployment created

Common Pitfalls

Common mistakes when setting resource requests include:

• Not specifying requests at all, which can cause pods to be scheduled on nodes without enough resources.
• Setting requests higher than limits, which is invalid and causes deployment errors.
• Using incorrect units or formats, like missing quotes or wrong suffixes.

Always ensure requests are less than or equal to limits and use correct units like "m" for CPU and "Mi" for memory.

yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: bad-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: bad
  template:
    metadata:
      labels:
        app: bad
    spec:
      containers:
      - name: bad-container
        image: nginx
        resources:
          requests:
            cpu: "500m"
            memory: "1Gi"
          limits:
            cpu: "300m"  # Wrong: limit less than request
            memory: "512Mi"  # Wrong: limit less than request

# Corrected version:
apiVersion: apps/v1
kind: Deployment
metadata:
  name: good-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: good
  template:
    metadata:
      labels:
        app: good
    spec:
      containers:
      - name: good-container
        image: nginx
        resources:
          requests:
            cpu: "300m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "1Gi"

Quick Reference

Summary tips for setting resource requests in Kubernetes deployments:

• Use resources.requests.cpu and resources.requests.memory to define minimum needed resources.
• CPU units: use "m" for milliCPU (e.g., "100m" = 0.1 CPU core).
• Memory units: use "Mi" or "Gi" for mebibytes/gibibytes (e.g., "256Mi").
• Requests must be less than or equal to limits if limits are set.
• Always quote resource values as strings in YAML.

Key Takeaways

Set resource requests under containers.resources.requests in your deployment YAML.

Requests define the minimum CPU and memory your pod needs to run properly.

Use correct units: "m" for CPU and "Mi" or "Gi" for memory, always quoted.

Ensure requests are less than or equal to limits to avoid deployment errors.

Not setting requests can cause pods to be scheduled on unsuitable nodes.