Kubernetes Resource Management Done Right

resource_characteristics:
  cpu:
    compressible: true
    exceeded_behavior: Throttling (process slows down)
    unit: Millicores (1000m = 1 core)
    impact: Performance degradation, not crashes

  memory:
    compressible: false
    exceeded_behavior: OOMKilled (process terminated)
    unit: Bytes (Mi, Gi)
    impact: Container restarts, potential data loss

requests:
  purpose: Scheduling and guaranteed resources
  guarantee: Always available to container
  scheduler: Uses for placement decisions
  formula: Sum(requests) <= Node allocatable

limits:
  purpose: Maximum resource usage
  behavior:
    cpu: Throttled when exceeded
    memory: OOMKilled when exceeded
  formula: Can exceed node capacity (overcommit)

# Typical patterns
cpu_settings:
  cpu_bound_workload:
    request: "500m"
    limit: null  # Often no limit is better
    rationale: Let it use available CPU

  latency_sensitive:
    request: "1000m"
    limit: "1000m"  # Guaranteed CPU
    rationale: Prevent noisy neighbor throttling

  background_job:
    request: "100m"
    limit: null
    rationale: Low priority, use spare CPU

# CPU limit considered harmful?
no_cpu_limit_argument:
  problem: CPU limits cause throttling even when CPU is available
  evidence:
    - Container gets throttled
    - Latency spikes at throttle boundaries
    - CPU sits idle while containers throttle

  recommendation:
    - Set requests accurately
    - Consider omitting CPU limits
    - Use resource quotas to prevent runaway
    - Monitor and adjust

# Memory requires limits
memory_settings:
  always_set_both:
    request: "256Mi"
    limit: "512Mi"  # 2x request typical
    rationale: Prevent OOMKills, allow burst

  equal_for_predictable:
    request: "512Mi"
    limit: "512Mi"
    rationale: Predictable, QoS Guaranteed

  sized_by_measurement:
    approach: Profile actual usage
    request: P90 actual usage
    limit: Maximum observed + buffer

# Average CPU usage
avg(rate(container_cpu_usage_seconds_total{
  namespace="production",
  container!="POD"
}[5m])) by (pod)

# P95 memory usage
quantile(0.95,
  container_memory_working_set_bytes{
    namespace="production",
    container!="POD"
  }
) by (pod)

# CPU throttling percentage
sum(rate(container_cpu_cfs_throttled_periods_total[5m]))
/
sum(rate(container_cpu_cfs_periods_total[5m]))
* 100

apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: my-app-vpa
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-app
  updatePolicy:
    updateMode: "Off"  # Just recommend
  resourcePolicy:
    containerPolicies:
      - containerName: app
        minAllowed:
          cpu: "50m"
          memory: "64Mi"
        maxAllowed:
          cpu: "2"
          memory: "2Gi"

# Get VPA recommendations
kubectl describe vpa my-app-vpa

# Look for:
# Target:     Cpu: 200m, Memory: 300Mi
# Lower Bound: Cpu: 50m, Memory: 100Mi
# Upper Bound: Cpu: 500m, Memory: 600Mi

qos_classes:
  guaranteed:
    condition: requests == limits (CPU and memory)
    priority: Highest (last to be evicted)
    use_case: Critical workloads

  burstable:
    condition: requests < limits
    priority: Medium
    use_case: Most workloads

  besteffort:
    condition: No requests or limits
    priority: Lowest (first evicted)
    use_case: Never in production

# Guaranteed QoS
apiVersion: v1
kind: Pod
spec:
  containers:
    - name: app
      resources:
        requests:
          cpu: "500m"
          memory: "256Mi"
        limits:
          cpu: "500m"      # Equal to request
          memory: "256Mi"  # Equal to request

eviction_thresholds:
  memory_available:
    soft: "100Mi"  # Graceful eviction starts
    hard: "50Mi"   # Immediate eviction

  nodefs_available:
    soft: "10%"
    hard: "5%"

eviction_order:
  1. BestEffort pods
  2. Burstable pods exceeding requests
  3. Burstable pods within requests
  4. Guaranteed pods (last resort)

# Namespace-level limits
apiVersion: v1
kind: ResourceQuota
metadata:
  name: compute-quota
  namespace: team-a
spec:
  hard:
    requests.cpu: "20"
    requests.memory: "40Gi"
    limits.cpu: "40"
    limits.memory: "80Gi"
    pods: "50"

# Default resources for pods without specifications
apiVersion: v1
kind: LimitRange
metadata:
  name: default-limits
spec:
  limits:
    - default:
        cpu: "500m"
        memory: "256Mi"
      defaultRequest:
        cpu: "100m"
        memory: "128Mi"
      max:
        cpu: "4"
        memory: "8Gi"
      min:
        cpu: "50m"
        memory: "64Mi"
      type: Container

oomkilled_diagnosis:
  check_events:
    command: kubectl describe pod <pod>
    look_for: "OOMKilled"

  check_metrics:
    query: container_memory_working_set_bytes vs limit

  solutions:
    - Increase memory limit
    - Fix memory leak in application
    - Profile actual memory usage

cpu_throttling_diagnosis:
  metrics:
    throttled: container_cpu_cfs_throttled_periods_total
    total: container_cpu_cfs_periods_total

  solutions:
    - Increase CPU limit
    - Remove CPU limit entirely
    - Use more replicas instead

pending_diagnosis:
  check_events:
    command: kubectl describe pod <pod>
    look_for: "Insufficient cpu/memory"

  solutions:
    - Reduce requests
    - Add nodes
    - Enable cluster autoscaler
    - Check node taints and tolerations