Feature	Pod Affinity	Intra-pod Affinity	Anti-Affinity
Definition	It schedules the requirements of the pod that required for placing it on a same node or others	Affinity or Anti-Affinity rules within a single pod with specifying the preferences for co-location or avoid the co-location of containers.	It defines the rules to discourage co-location of the pods on the same node or within the same pod promoting the distribution across multiple nodes
Use Case	Co-location of pods that belonging to related services to optimize the communication and resource utilization.	It ensure the certain containers within pod for scheduling together or apart based on their requirements or dependencies.	It prevents the single points of failures by spreading the pods across different nodes or containers within the same pod.
Example	It scheduling pods of frontend and backend service on the same node helps in reducing the network latency.	It co-locates the containers withing a pod that requires the high-speed inter-process communication.	It avoids the scheduling multiple instances of a critical service on a single node for increasing fault tolerance.
Kubernetes API	podAffinity	Not applicable	Pod Anti Affinity

How to Assign Pods to Nodes Using Node Affinity ? A Step-By-Step Guide

Assigning the pds to Nodes using the node affinity provides the control on which nodes our pods to be scheduled, based on the node labels. The following is the step by step guide for assigning the pods to nodes using node affinity:

Step 1: Firstly ensure that the kuberentes cluster is in running state with kubernetes master and worker nodes.

Step 2: Create label the nodes with their specifications so that we can make easier to deploy pods on where we want to deploy. The following command helps in setting the labels to the nodes.

kubectl label nodes <node-names> <label-key>=<label-value>

Step 3: Define the node affinity in Pod Yaml

• In you pod manefist file, try to define the node affinity rules under the spec section. The following is an example of Yaml code:

spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: <label-key>
            operator: In
            values:
            - <label-value>

Step 4: Apply the pod configuration

• After once defining the affinity rules save the yaml configuration file and apply it using the following command:

kubectl apply -f <file_name.yaml>

Step 5: Verify Pod Placement

• Verify on where the pod is placement on the Node with the following command;

kubectl get pods -o wide

Adding A Label to a Node

On adding the labels to the nodes provides to specify additional metadata to the node, which can be used for various purposes like node selection, scheduling and grouping.

• The following command is used for adding label to the node:

kubectl label nodes <node-name> <label-key>=<label-value>

• Verify the labels of the node with the following command:

# Add Label to Node
kubectl label nodes <node-name> <label-key>=<label-value>

Schedule A Pod Using Required Node Affinity

The following are the steps for sechule a pod using required Node Affinity:

Step 1: Identiy the Node Label

• Firstly identify the node on which you want to deploy the pod, know its node labels.

Step 2: Deine Pod Yaml

• Create a pod yaml manifest with the required node affinity specified rules under the spec section.

# Define Pod YAML with Required Node Affinity
apiVersion: v1
kind: Pod
metadata:
  name: pod-with-required-affinity
spec:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: <label-key>
            operator: In
            values:
            - <label-value>
  containers:
  - name: example-container
    image: nginx:latest

Step 3: Apply Pod Configuration

• After once configured and defined the affinity rules in the yaml manifest file save it and then apply the changes with the following command:

kubectl apply -f pod-with-required-affinity.yaml  

Step 4: Verify Pod Placement

• Now, check the pod is scheduled on a node with the specified label using the following command:

kubectl get pods -o wide

Schedule a Pod Using Preferred Node Affinity

The following are the steps for scheduling the pod using preferred Node Affinity:

Step 1: Identify the Node Label

• Firstly identify the node on which you want to deploy the pod, know its node labels.

Step 2: Define Pod Yaml

• Create a pod manifest Yaml with preferred node affinity specified under the spec section.

# Define Pod YAML with Preferred Node Affinity
apiVersion: v1
kind: Pod
metadata:
  name: pod-with-preferred-affinity
spec:
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 1
        preference:
          matchExpressions:
          - key: <label-key>
            operator: In
            values:
            - <label-value>
  containers:
  - name: example-container
    image: nginx:latest

Step 3: Apply Pod Configuration

• Using the following command you can apply the pod configuration:

kubectl apply -f pod-with-preferred-affinity.yaml

Step 4: Verify the Pod Placement

• Check the pod scheduled on a node with the specified labels using the following command:

kubectl get pods -o wide

Assigning Pods to Nodes

The following are the steps for assigning the pods to nodes:

Step 1: Label the Nodes

• Firstly Identify the node where you want to schedule th pods and provide the labels to the node with the following command:

kubectl label nodes node-1 environment=production

Step 2: Create Pod Yaml File

• Now, Create pod manefist file to schedule the pod on the specific labeled node. The pod manifest file looks as follows:

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

Step 3: Apply Configuration

• Once, you configured the pod manefist file, use the following command to apply the configuration:

 kubectl apply -f pod.yaml

Step 4: Verify Pod Placement

• Check the pod is scheduled on the desired node using the following command:

 kubectl get pods -o wide

Command to See Existing labels of the Node

The following is the command used to see the existing labels of the Node:

kubectl get nodes --show-labels

Command to set New Labels to Node

The following is the command used to set the new labels to the Node:

kubectl label nodes <node-name> <label-key>=<label-value>

Example of NodeAffinity

You must include the selector rules in the pod’s YAML definition file in order to use the node selector in Kubernetes. For example, the YAML file below defines a pod with a necessary node selector for nodes with the label “nginx” 

In the following example, we have used the ‘nodeSelector’ parameter for showing the required node affinity for nodes that do have the label ‘nginx’. This means that the pod will be scheduled on the nodes which contain this label.

Let’s take another example of Node Affinity. For this, we will first create a deployment. The deployment will have the following features:

• name: Blue
• image: nginx
• replicas: 3

In order to create this deployment we can use two different approaches. However, for simplicity, we will use an imperative approach. We can create this deployment using the command:

• To check whether or not the deployment was created successfully, execute the command:

•  We have two nodes in my cluster, the control plane, and node01. 

• For this example, we want to Set Node Affinity to the deployment to place the pods on node01 only.

1. Name of the deployment: blue
2. Replicas: 3
3. Image: nginx
4. NodeAffinity: requiredDuringSchedulingIgnoredDuringExecution
5. Key: color
6. value: blue

• In order to achieve this, we will edit the deployment using:

• Once we are in we will add the following block of script on the same level of container:

• The specs of a Kubernetes object are specified in the “spec” field. It is used for defining the pod’s affinity rules.
• The node affinity and all other scheduling preferences for the pod are mentioned in the “affinity” column. The preferences of the pod for the nodes on which it is scheduled are specified in the “node affinity” column.
• The nodeSelectorTerms requirements must be met for the pod to be scheduled, according to the “requiredDuringSchedulingIgnoredDuringExecution” parameter. The rules are ignored while the pod is being executed, thus if the node’s labels change while the pod is running, it won’t be rescheduled.
• The ‘nodeSelectorTerms’ field is used to define the requirements for a node to satisfy for scheduling. It has mentioned the ‘matchExpressions’ field in its instance.
• In this, we have used the ‘matchExpressions’ for specifying a set of label selectors to match with the labels specified on the node. We have used the operator ‘In’ and the corresponding values ‘blue’ are matching against the ‘color’ label key.
• Thus, this code directs that the pod be scheduled on nodes that have the label “color” and the value “blue” assigned to them.
• Once we have updated the file, We can see that the pods are running on node01. To check the configuration we should run the command:

As we can see that all the pods are deployed on the node01 node. In Conclusion, your Kubernetes clusters’ performance and resource efficiency may be enhanced by using node affinity. Assuring that your pods are scheduled on nodes with the resources they require through the use of node affinity can help to reduce resource contention and enhance application performance.

Kubernetes Node Affinity – FAQs

What are the two types of Kubernetes Nodes?

Master Node and Worker Node are the two types of kubernetes Nodes.

What is the affinity rule in kubernetes?

An affinity node in kubernetes specifies the preferences and requirements for pod placement based on the factors like node labels or pod labels.

What are hard and soft affinity in kubernetes?

Hard Affinity provides the strict rules for pod placement whereas soft affinity provides the preferences but allows for exception.

What is Topology key in kubernetes?

Topology Key in kubernetes is a filed used in affinity and anti-affinity rules to define the level of affinity such as node, zone or region.

How to remove Node affinity in Kubernetes?

On updating the pod yaml manifest file to remove the nodeAffinity section or setting it to null and then applying it changes using the following command we can remove the Node Affinity in kubernetes.

kubectl apply -f <filename.yaml>