Lesson 12: Advanced Scheduling and Resource Management

In this lesson, we will explore advanced scheduling techniques and resource management strategies in Kubernetes. Understanding these concepts is crucial for optimizing your applications and ensuring efficient resource utilization in your clusters.

Advanced Scheduling Techniques

Kubernetes uses a scheduler to assign pods to nodes. The default scheduler is sufficient for most use cases, but there are scenarios where advanced scheduling techniques can enhance performance and resource management.

Custom Schedulers

You can create custom schedulers to implement specific scheduling policies. A custom scheduler can be implemented as a separate service that watches for unscheduled pods and assigns them to nodes based on your criteria.

Here is a simple example of how to create a custom scheduler:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
    - name: my-container
      image: my-image
  schedulerName: my-custom-scheduler

Affinity and Anti-Affinity Rules

Affinity and anti-affinity rules allow you to control how pods are placed relative to each other. You can specify these rules in your pod specifications.

Node Affinity

Node affinity allows you to constrain which nodes your pod is eligible to be scheduled based on labels on nodes. Here’s an example:

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

Pod Affinity

Pod affinity allows you to schedule pods based on the presence of other pods. Here’s an example of pod affinity:

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

Taints and Tolerations

Taints and tolerations are mechanisms to control which pods can be scheduled on particular nodes. Taints are applied to nodes, while tolerations are applied to pods.

Adding Taints to Nodes

You can add taints to nodes using the following command:

kubectl taint nodes node1 key=value:NoSchedule

Adding Tolerations to Pods

Here’s how to add tolerations to a pod:

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

Resource Management Strategies

Efficient resource management is key to maximizing the performance of your Kubernetes cluster. Here are some strategies:

Resource Requests and Limits

Setting resource requests and limits for your containers ensures that they have the necessary resources while avoiding resource contention.

Example of Resource Requests and Limits

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

Horizontal Pod Autoscaler

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

Example of HPA

apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
  name: my-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-deployment
  minReplicas: 1
  maxReplicas: 10
  targetCPUUtilizationPercentage: 50

Best Practices and Common Mistakes

Best Practice: Always set resource requests and limits for your containers to avoid resource contention and ensure fair usage.

Common Mistake: Forgetting to account for the overhead of system components when setting resource limits, which can lead to scheduling failures.

Summary

• Custom schedulers can be used for specific scheduling policies.
• Affinity and anti-affinity rules help control pod placement based on labels.
• Taints and tolerations manage which pods can run on specific nodes.
• Resource requests and limits are essential for efficient resource management.
• The Horizontal Pod Autoscaler automatically adjusts the number of pods based on metrics.

• Exercise 1: Create a custom scheduler and deploy a pod using that scheduler.

• Task: Write a YAML file for a pod that uses a custom scheduler.

• Exercise 2: Implement node affinity for a pod.

• Task: Modify a pod definition to include node affinity based on a custom label.

• Exercise 3: Set resource requests and limits for an existing deployment.

• Task: Update a deployment to include resource requests and limits for its containers.

• Understand advanced scheduling techniques like custom schedulers and affinity rules.
• Learn how to use taints and tolerations for node management.
• Implement resource requests and limits for better resource utilization.
• Use the Horizontal Pod Autoscaler to scale applications automatically.