Pod Scheduling

🎯 Kubernetes Pod Scheduling: The School Bus Story

Imagine you’re the principal of a magical school with many school buses (nodes) and hundreds of students (pods) who need rides. Your job? Make sure every student gets on the RIGHT bus to the RIGHT place!

🚌 What is Pod Scheduling?

Simple idea: Kubernetes needs to decide which computer (node) should run your app (pod).

Think of it like this:

• Pods = Students waiting for a ride
• Nodes = School buses
• Scheduler = The smart principal who assigns students to buses

Real Example:

# A simple pod (student) waiting for a bus
apiVersion: v1
kind: Pod
metadata:
  name: my-app
spec:
  containers:
  - name: app
    image: nginx

The scheduler picks the best node automatically!

🔄 The Scheduling Pipeline: How the Principal Decides

The scheduler doesn’t just throw students on random buses. It follows a smart process:

graph TD
    A["New Pod Created"] --> B["Filtering"]
    B --> C["Scoring"]
    C --> D["Binding"]
    D --> E["Pod Running!"]

Step 1: Filtering 🔍

“Which buses CAN take this student?”

• Remove buses that are full
• Remove buses going the wrong direction
• Keep only valid options

Step 2: Scoring ⭐

“Which bus is BEST for this student?”

• Score each remaining bus
• Consider resources, location, preferences
• Pick the highest score

Step 3: Binding 🔗

“Put the student on the bus!”

• Assign the pod to the chosen node
• Pod starts running

🏷️ Node Selectors: Simple Bus Preferences

What is it? The easiest way to say “I want THIS type of bus!”

Like saying: “I only ride the blue buses!”

apiVersion: v1
kind: Pod
metadata:
  name: gpu-app
spec:
  nodeSelector:
    gpu: "true"    # Only buses with GPU label
  containers:
  - name: ml-training
    image: tensorflow

How it works:

1. Your node has a label: gpu=true
2. Pod says: “I need gpu=true”
3. Scheduler matches them! ✅

Real Life Example:

• Node A: disk=ssd, region=east
• Node B: disk=hdd, region=west
• Pod wants: disk=ssd → Goes to Node A!

💪 Node Affinity: Advanced Bus Preferences

What is it? Like node selectors, but with SUPERPOWERS!

Think of it as: “I REALLY prefer blue buses, but yellow is okay too.”

Two Types:

apiVersion: v1
kind: Pod
metadata:
  name: smart-app
spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: zone
            operator: In
            values:
            - us-east-1a
            - us-east-1b

Operators you can use:

• In – value is in the list
• NotIn – value is NOT in the list
• Exists – label exists (any value)
• DoesNotExist – label doesn’t exist
• Gt, Lt – greater than, less than

🚫 Taints and Tolerations: “No Entry” Signs

The Story:

Some buses have special rules. A bus might say:

“NO students allowed… unless you have a special pass!”

• Taint = The “No Entry” sign on the bus
• Toleration = The special pass that lets you in

Adding a Taint to a Node:

kubectl taint nodes node1 special=gpu:NoSchedule

This says: “Node1 is special. Regular pods, stay away!”

Giving a Pod the Pass (Toleration):

apiVersion: v1
kind: Pod
metadata:
  name: gpu-pod
spec:
  tolerations:
  - key: "special"
    operator: "Equal"
    value: "gpu"
    effect: "NoSchedule"
  containers:
  - name: app
    image: nvidia-cuda

Three Taint Effects:

🆚 Taints vs Tolerations: The Difference

Think of it as a lock and key:

Key insight:

• Taint = Node saying “NO!”
• Toleration = Pod saying “I’m allowed!”

A toleration doesn’t mean “go there.” It means “I CAN go there if needed.”

👫 Pod Affinity: Buddies Ride Together

What is it? Make pods that like each other sit together!

Like saying: “I want to sit near my friend who’s already on a bus.”

apiVersion: v1
kind: Pod
metadata:
  name: web-server
spec:
  affinity:
    podAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
          matchLabels:
            app: cache
        topologyKey: kubernetes.io/hostname

Translation: “Put me on the same node as pods with app=cache”

Why useful?

• Web server near cache = faster!
• Database replicas together = less network delay

🙅 Pod Anti-Affinity: Spread Apart!

What is it? Make pods that should NOT be together stay apart!

Like saying: “I don’t want to be on the same bus as my sibling.”

apiVersion: v1
kind: Pod
metadata:
  name: replica-1
  labels:
    app: myapp
spec:
  affinity:
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
          matchLabels:
            app: myapp
        topologyKey: kubernetes.io/hostname

Translation: “Don’t put me on the same node as other app=myapp pods”

Why useful?

• High availability: if one node dies, other replicas survive!
• Spread load across nodes

🥇 Pod Priority and Preemption: VIP Students

What is it? Some students are VIPs. When the bus is full, they can kick out regular students!

How it works:

1. You create Priority Classes (VIP levels)
2. Assign priority to pods
3. When resources are tight, high-priority pods win!

graph TD
    A["Bus is FULL"] --> B["VIP Student Arrives"]
    B --> C["Scheduler finds low-priority student"]
    C --> D["Low-priority student removed"]
    D --> E["VIP student gets seat!"]

🎖️ Priority Classes: The VIP Levels

What is it? Define different importance levels for your pods.

Creating a Priority Class:

apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: high-priority
value: 1000000
globalDefault: false
description: "Critical production workloads"

Using it in a Pod:

apiVersion: v1
kind: Pod
metadata:
  name: important-app
spec:
  priorityClassName: high-priority
  containers:
  - name: app
    image: myapp

Built-in Priority Classes:

Preemption in Action:

1. High-priority pod can’t find a node
2. Scheduler looks for low-priority pods to evict
3. Low-priority pods get gracefully terminated
4. High-priority pod takes their place!

🎓 Summary: The Complete Picture

graph TD
    A["Pod Created"] --> B{Scheduling Pipeline}
    B --> C["Filter Nodes"]
    C --> D["Score Nodes"]
    D --> E["Check Node Selectors"]
    E --> F["Check Node Affinity"]
    F --> G["Check Taints/Tolerations"]
    G --> H["Check Pod Affinity/Anti-Affinity"]
    H --> I["Check Priority"]
    I --> J["Bind to Best Node!"]

Quick Reference:

🚀 You Did It!

You now understand how Kubernetes acts like a smart school principal:

• Filtering buses that can take students
• Scoring to find the best match
• Respecting preferences and restrictions
• Handling VIPs when space is tight

Remember: The scheduler’s job is to make everyone happy—pods get the right nodes, and nodes don’t get overwhelmed!

🎉 Congratulations! You’re now a Pod Scheduling expert!