Lesson 11: Advanced Scheduling and Resource Management

In this lesson, we will explore advanced scheduling techniques and resource management in Kubernetes. Understanding how to effectively manage resources and schedule workloads is crucial for optimizing application performance and ensuring efficient use of cluster resources.

Table of Contents

1. Understanding Kubernetes Scheduler
2. Node Affinity and Taints/Tolerations
3. Resource Requests and Limits
4. Quality of Service (QoS)
5. Best Practices and Common Mistakes

Understanding Kubernetes Scheduler

The Kubernetes Scheduler is responsible for assigning Pods to Nodes based on resource availability and scheduling policies. It considers various factors, including resource requests, constraints, and affinity rules.

Custom Scheduler

You can create a custom scheduler if the default behavior does not meet your requirements. Here’s a basic example of a custom scheduler configuration:

apiVersion: v1
kind: ConfigMap
metadata:
  name: custom-scheduler-config
data:
  scheduler.conf: |
    apiVersion: scheduling.k8s.io/v1
    kind: Scheduler
    name: custom-scheduler
    ... # additional configuration

Node Affinity and Taints/Tolerations

Node Affinity allows you to constrain which nodes your Pods are eligible to be scheduled based on labels on the nodes. Taints and tolerations are mechanisms that allow nodes to repel certain Pods unless they tolerate the taint.

Example of Node Affinity

Here’s an example of a Pod specification using node affinity:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: disktype
            operator: In
            values:
            - ssd
  containers:
  - name: my-container
    image: my-image:latest

Example of Taints and Tolerations

To apply a taint to a node:

kubectl taint nodes my-node key=value:NoSchedule

And here’s how to add a toleration to a Pod:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  tolerations:
  - key: "key"
    operator: "Equal"
    value: "value"
    effect: "NoSchedule"
  containers:
  - name: my-container
    image: my-image:latest

Resource Requests and Limits

Resource requests and limits allow you to specify the minimum and maximum amount of CPU and memory that a container can use. This helps the scheduler make better decisions and ensures that your applications do not consume more resources than intended.

Example of Resource Requests and Limits

Here’s a Pod configuration that specifies resource requests and limits:

apiVersion: v1
kind: Pod
metadata:
  name: resource-limits-pod
spec:
  containers:
  - name: my-container
    image: my-image:latest
    resources:
      requests:
        memory: "64Mi"
        cpu: "250m"
      limits:
        memory: "128Mi"
        cpu: "500m"

Quality of Service (QoS)

Kubernetes classifies Pods into three QoS classes based on their resource requests and limits: - Guaranteed: If limits and requests are set and equal. - Burstable: If limits are set, but requests are lower than limits. - BestEffort: If no requests or limits are set.

Best Practices and Common Mistakes

Best Practice: Always set resource requests and limits to prevent resource contention. Common Mistake: Forgetting to use tolerations when applying taints to nodes can lead to Pods not being scheduled.

Best Practice: Use node affinity to schedule Pods on specific nodes that meet certain criteria. Common Mistake: Overloading nodes with too many Pods can lead to performance degradation.

Conclusion

In this lesson, we covered advanced scheduling techniques and resource management in Kubernetes. Understanding these concepts is essential for optimizing your applications and ensuring efficient resource usage in your Kubernetes cluster.

Exercise 1: Implement Node Affinity

1. Create a new node label zone=us-west on one of your nodes: bash kubectl label nodes <node-name> zone=us-west
2. Modify a Pod specification to use node affinity to schedule it only on nodes with the label zone=us-west.

Exercise 2: Configure Resource Requests and Limits

1. Create a Pod with resource requests of 100Mi memory and 200m CPU.
2. Set limits for the same Pod to 200Mi memory and 400m CPU.

Exercise 3: Apply Taints and Tolerations

1. Taint a node with a key-value pair of your choice.
2. Create a Pod that tolerates this taint.

• Kubernetes Scheduler assigns Pods to Nodes based on resource availability and scheduling policies.
• Node Affinity allows Pods to be scheduled on specific nodes based on labels.
• Resource requests and limits help manage CPU and memory usage effectively.
• Quality of Service (QoS) classifies Pods based on their resource configurations.
• Always set resource limits and requests to prevent resource contention.