A Student and Classroom Analogy

Kubernetes is a powerful orchestration tool, but some of its concepts can be tricky to grasp. In this blog post, we’ll use the analogy of students (Pods) and classrooms (Nodes) to explain Taints, Tolerations, Node Affinity, and Node Selectors. We’ll also dive deeper into the two types of Node Affinity: requiredDuringSchedulingIgnoredDuringExecution and preferredDuringSchedulingIgnoredDuringExecution. By the end, you’ll understand how these features help Kubernetes manage Pod scheduling effectively.

1. Taints and Tolerations: Restricting Access to Classrooms

Taints (Classroom Rules)

Imagine a school with multiple classrooms, and each classroom has a specific rule about which students can enter based on the color of their dress. For example:

• White Classroom: Only students wearing a white dress can enter.

• Blue Classroom: Only students wearing a blue dress can enter.

In Kubernetes, a Taint is like a rule on a Node (classroom) that restricts which Pods (students) can run on it. If a Node has a Taint, only Pods with a matching Toleration can be scheduled on that Node.

Tolerations (Student Permissions)

A Toleration is like a permission slip that allows a student to enter a specific classroom. For example:

• A student with a white dress has a Toleration for the White Classroom.

• A student with a blue dress has a Toleration for the Blue Classroom.

If a student doesn’t have the right Toleration, they can’t enter the classroom and must go to another one.

Example: Taints and Tolerations in Kubernetes

Taint a Node (Classroom Rule)

Let’s say we have a Node (classroom) that only allows Pods (students) with the dress-color=white Taint. Here’s how you’d add the Taint:

kubectl taint nodes node1 dress-color=white:NoSchedule

This means:

• Key: dress-color

• Value: white

• Effect: NoSchedule (Pods without a matching Toleration won’t be scheduled here).

Add a Toleration to a Pod (Student Permission)

Now, let’s create a Pod (student) that can tolerate the dress-color=white Taint:

apiVersion: v1
kind: Pod
metadata:
  name: white-student
spec:
  containers:
  - name: nginx
    image: nginx:latest
  tolerations:
  - key: "dress-color"
    operator: "Equal"
    value: "white"
    effect: "NoSchedule"

This Pod can now be scheduled on the node1 Node because it has the right Toleration.

2. Node Affinity: Preferred Classrooms

Node Affinity is like a student’s preference or requirement for a specific classroom. There are two types of Node Affinity:

1. requiredDuringSchedulingIgnoredDuringExecution: The student must go to a specific classroom. If the classroom isn’t available, the student won’t be scheduled.

2. preferredDuringSchedulingIgnoredDuringExecution: The student prefers a specific classroom but can go to another classroom if needed.

Example: Node Affinity in Kubernetes

Required Node Affinity (requiredDuringSchedulingIgnoredDuringExecution)

Let’s say we want a Pod (student) to only run on Nodes (classrooms) with the label dress-color=blue. If no such Node is available, the Pod won’t be scheduled.

apiVersion: v1
kind: Pod
metadata:
  name: blue-student
spec:
  containers:
  - name: nginx
    image: nginx:latest
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: dress-color
            operator: In
            values:
            - blue

This Pod will only be scheduled on Nodes with the dress-color=blue label. If no such Node exists, the Pod will remain unscheduled.

Preferred Node Affinity (preferredDuringSchedulingIgnoredDuringExecution)

Let’s say we want a Pod (student) to prefer Nodes (classrooms) with the label dress-color=white but can be scheduled on other Nodes if necessary.

apiVersion: v1
kind: Pod
metadata:
  name: white-student
spec:
  containers:
  - name: nginx
    image: nginx:latest
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 1
        preference:
          matchExpressions:
          - key: dress-color
            operator: In
            values:
            - white

This Pod will prefer Nodes with the dress-color=white label but can be scheduled on other Nodes if no white-labeled Nodes are available.

3. Node Selectors: Mandatory Classrooms

Node Selectors are like strict rules for students. For example:

• A student must go to the Blue Classroom and no other.

In Kubernetes, Node Selectors are used to specify that a Pod must be scheduled on a Node with specific labels.

Example: Node Selector in Kubernetes

Let’s say we want a Pod (student) to only run on Nodes (classrooms) with the label dress-color=green:

apiVersion: v1
kind: Pod
metadata:
  name: green-student
spec:
  containers:
  - name: nginx
    image: nginx:latest
  nodeSelector:
    dress-color: green

This Pod will only be scheduled on Nodes with the dress-color=green label.

4. Key Differences Between Node Affinity and Node Selectors

5. Putting It All Together: A Real-World Scenario

Imagine a school with the following setup:

• White Classroom: Only students wearing white dresses can enter (Taint and Toleration).

• Blue Classroom: Students must go here if they wear blue (Required Node Affinity).

• Green Classroom: Students prefer this classroom but can go elsewhere (Preferred Node Affinity).

• Red Classroom: Students must go here if they wear red (Node Selector).

Kubernetes YAML Example

White Classroom (Taint and Toleration)

1. Taint the Node:

    kubectl taint nodes node1 dress-color=white:NoSchedule
   

2. Create a Pod with a Toleration:

    apiVersion: v1
    kind: Pod
    metadata:
      name: white-student
    spec:
      containers:
      - name: nginx
        image: nginx:latest
      tolerations:
      - key: "dress-color"
        operator: "Equal"
        value: "white"
        effect: "NoSchedule"
   

Blue Classroom (Required Node Affinity)

Create a Pod with Required Node Affinity:

apiVersion: v1
kind: Pod
metadata:
  name: blue-student
spec:
  containers:
  - name: nginx
    image: nginx:latest
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: dress-color
            operator: In
            values:
            - blue

Green Classroom (Preferred Node Affinity)

Create a Pod with Preferred Node Affinity:

apiVersion: v1
kind: Pod
metadata:
  name: green-student
spec:
  containers:
  - name: nginx
    image: nginx:latest
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 1
        preference:
          matchExpressions:
          - key: dress-color
            operator: In
            values:
            - green

Red Classroom (Node Selector)

Create a Pod with a Node Selector:

apiVersion: v1
kind: Pod
metadata:
  name: red-student
spec:
  containers:
  - name: nginx
    image: nginx:latest
  nodeSelector:
    dress-color: red

6. Conclusion

By using the analogy of students and classrooms, we’ve explored how Kubernetes uses Taints, Tolerations, Node Affinity, and Node Selectors to manage Pod scheduling. Here’s a quick recap:

• Taints and Tolerations: Restrict Pods from running on certain Nodes unless they have the right permissions.

• Node Affinity:

  • requiredDuringSchedulingIgnoredDuringExecution: Enforces strict rules for Pod scheduling.

  • preferredDuringSchedulingIgnoredDuringExecution: Allows Pods to express preferences for specific Nodes.

• Node Selectors: Enforce strict rules for Pod scheduling.

These features give you fine-grained control over where your Pods run, ensuring your applications are deployed efficiently and reliably.

Happy Kuberneting! 🚀

References :

https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/

https://theithollow.com/2019/07/29/kubernetes-taints-and-tolerations/

https://bhavyasree.github.io/kubernetes-CKAD/16.taints&tolerations-Vs-nodeaffinity/#using-taintstolerations-and-node-affinity

https://github.com/kodekloudhub/certified-kubernetes-administrator-course