Lesson 12: Advanced Scheduling and Resource Management in Kubernetes

In this lesson, we will explore advanced scheduling features and resource management techniques in Kubernetes. Understanding these concepts will help you optimize the performance and resource utilization of your applications in a Kubernetes environment.

Advanced Scheduling Features

Kubernetes scheduling is the process of selecting a suitable node for a pod to run on. While the default scheduler handles basic scheduling needs, advanced features allow for more sophisticated scheduling decisions:

1. Affinity and Anti-Affinity

Affinity rules allow you to specify that certain pods should be scheduled on the same node or on different nodes. This is useful for co-locating services that need to communicate frequently or isolating services for performance reasons.

Node Affinity

Node affinity allows you to constrain which nodes your pod is eligible to be scheduled based on labels on the nodes.

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

Pod Anti-Affinity

Pod anti-affinity allows you to specify that certain pods should not be scheduled on the same node.

apiVersion: v1
kind: Pod
metadata:
  name: my-app
spec:
  affinity:
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
          matchExpressions:
          - key: app
            operator: In
            values:
            - my-app
        topologyKey: "kubernetes.io/hostname"
  containers:
  - name: my-container
    image: my-image

2. Taints and Tolerations

Taints and tolerations are mechanisms that allow a node to repel a set of pods unless those pods have matching tolerations.

Taint a Node

kubectl taint nodes my-node key=value:NoSchedule

Add Toleration to Pod

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

Resource Management Techniques

Kubernetes allows you to manage resources effectively using requests and limits:

1. Resource Requests and Limits

Resource requests and limits allow you to define the minimum and maximum resources that a container can use.

Define Requests and Limits

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

2. Horizontal Pod Autoscaling

Horizontal Pod Autoscaler (HPA) automatically scales the number of pods in a deployment based on observed CPU utilization or other select metrics.

Create HPA

kubectl autoscale deployment my-app --cpu-percent=50 --min=1 --max=10

Best Practices and Common Mistakes

Best Practice: Always set resource requests and limits to ensure that your applications have the resources they need without overwhelming the nodes.

Common Mistake: Forgetting to define tolerations when using taints can lead to pods not being scheduled on nodes where they are needed.

Summary

• Kubernetes provides advanced scheduling features like affinity, anti-affinity, taints, and tolerations.
• Resource management is crucial for maintaining application performance and stability.
• Always define resource requests and limits for your containers to optimize resource utilization.
• Use Horizontal Pod Autoscaling to dynamically adjust the number of pods based on load.
• Be aware of best practices to avoid common scheduling and resource management mistakes.

1. Create a Pod with Node Affinity: Modify the provided Pod YAML to add node affinity that requires the pod to run on nodes labeled with disktype: ssd.

2. Implement Taints and Tolerations: Taint a node with a key-value pair and create a Pod YAML that includes the toleration for this taint.

3. Set Resource Requests and Limits: Update an existing deployment to include resource requests for CPU and memory, ensuring it has a limit as well.

• Advanced scheduling features include affinity, anti-affinity, taints, and tolerations.
• Resource requests and limits are essential for effective resource management.
• Horizontal Pod Autoscaler helps maintain application performance under varying loads.
• Setting proper resource limits prevents node resource exhaustion and improves stability.
• Following best practices can avoid common pitfalls in Kubernetes resource management.