Advanced Scheduling and Node Affinity

Overview

Node affinity is a set of rules used by the scheduler to determine where a pod can be placed. The rules are defined using custom labels on nodes and label selectors specified in pods. Node affinity allows a pod to specify an affinity (or anti-affinity) towards a group of nodes it can be placed on. The node does not have control over the placement.

For example, you could configure a pod to only run on a node with a specific CPU or in a specific availability zone.

There are two types of node affinity rules: required and preferred.

Required rules must be met before a pod can be scheduled on a node. Preferred rules specify that, if the rule is met, the scheduler tries to enforce the rules, but does not guarantee enforcement.

If labels on a node change at runtime that results in an node affinity rule on a pod no longer being met, the pod continues to run on the node.

Configuring Node Affinity

You configure node affinity through the pod specification file. You can specify a required rule, a preferred rule, or both. If you specify both, the node must first meet the required rule, then attempts to meet the preferred rule.

The following example is a pod specification with a rule that requires the pod be placed on a node with a label whose key is e2e-az-NorthSouth and whose value is either e2e-az-North or e2e-az-South:

Sample pod configuration file with a node affinity required rule

  1. apiVersion: v1
  2. kind: Pod
  3. metadata:
  4.   name: with-node-affinity
  5. spec:
  6.   affinity:
  7.     nodeAffinity: (1)
  8.       requiredDuringSchedulingIgnoredDuringExecution: (2)
  9.         nodeSelectorTerms:
  10.         - matchExpressions:
  11.           - key: e2e-az-NorthSouth (3)
  12.             operator: In (4)
  13.             values:
  14.             - e2e-az-North (3)
  15.             - e2e-az-South (3)
  16.   containers:
  17.   - name: with-node-affinity
  18.     image: docker.io/ocpqe/hello-pod
1The stanza to configure node affinity.
2Defines a required rule.
3The key/value pair (label) that must be matched to apply the rule.
4The operator represents the relationship between the label on the node and the set of values in the matchExpression parameters in the pod specification. This value can be In, NotIn, Exists, or DoesNotExist, Lt, or Gt.

The following example is a node specification with a preferred rule that a node with a label whose key is e2e-az-EastWest and whose value is either e2e-az-East or e2e-az-West is preferred for the pod:

Sample pod configuration file with a node affinity preferred rule

  1. apiVersion: v1
  2. kind: Pod
  3. metadata:
  4.   name: with-node-affinity
  5. spec:
  6.   affinity:
  7.     nodeAffinity: (1)
  8.       preferredDuringSchedulingIgnoredDuringExecution: (2)
  9.       - weight: 1 (3)
  10.         preference:
  11.           matchExpressions:
  12.           - key: e2e-az-EastWest (4)
  13.             operator: In (5)
  14.             values:
  15.             - e2e-az-East (4)
  16.             - e2e-az-West (4)
  17.   containers:
  18.   - name: with-node-affinity
  19.     image: docker.io/ocpqe/hello-pod
1The stanza to configure node affinity.
2Defines a preferred rule.
3Specifies a weight for a preferred rule. The node with highest weight is preferred.
4The key/value pair (label) that must be matched to apply the rule.
5The operator represents the relationship between the label on the node and the set of values in the matchExpression parameters in the pod specification. This value can be In, NotIn, Exists, or DoesNotExist, Lt, or Gt.

There is no explicit node anti-affinity concept, but using the NotIn or DoesNotExist operator replicates that behavior.

If you are using node affinity and node selectors in the same pod configuration, note the following:

  • If you configure both nodeSelector and nodeAffinity, both conditions must be satisfied for the pod to be scheduled onto a candidate node.

  • If you specify multiple nodeSelectorTerms associated with nodeAffinity types, then the pod can be scheduled onto a node if one of the nodeSelectorTerms is satisfied.

  • If you specify multiple matchExpressions associated with nodeSelectorTerms, then the pod can be scheduled onto a node only if all matchExpressions are satisfied.

Configuring a Required Node Affinity Rule

Required rules must be met before a pod can be scheduled on a node.

The following steps demonstrate a simple configuration that creates a node and a pod that the scheduler is required to place on the node.

  1. Add a label to a node by editing the node configuration or by using the oc label node command:

    1. $ oc label node node1 e2e-az-name=e2e-az1

    To modify a node in your cluster, update the node configuration maps as needed. Do not manually edit the node-config.yaml file.

  2. In the pod specification, use the nodeAffinity stanza to configure the requiredDuringSchedulingIgnoredDuringExecution parameter:

    1. Specify the key and values that must be met. If you want the new pod to be scheduled on the node you edited, use the same key and value parameters as the label in the node.

    2. Specify an operator. The operator can be In, NotIn, Exists, DoesNotExist, Lt, or Gt. For example, use the operator In to require the label to be in the node:

      1. spec:
      2.   affinity:
      3.     nodeAffinity:
      4.       requiredDuringSchedulingIgnoredDuringExecution:
      5.         nodeSelectorTerms:
      6.         - matchExpressions:
      7.           - key: e2e-az-name
      8.             operator: In
      9.             values:
      10.             - e2e-az1
      11.             - e2e-az2

  1. Create the pod:

    1. $ oc create -f e2e-az2.yaml

Configuring a Preferred Node Affinity Rule

Preferred rules specify that, if the rule is met, the scheduler tries to enforce the rules, but does not guarantee enforcement.

The following steps demonstrate a simple configuration that creates a node and a pod that the scheduler tries to place on the node.

  1. Add a label to a node by editing the node configuration or by executing the oc label node command:

    1. $ oc label node node1 e2e-az-name=e2e-az3

    To modify a node in your cluster, update the node configuration maps as needed. Do not manually edit the node-config.yaml file.

  2. In the pod specification, use the nodeAffinity stanza to configure the preferredDuringSchedulingIgnoredDuringExecution parameter:

    1. Specify a weight for the node, as a number 1-100. The node with highest weight is preferred.

    2. Specify the key and values that must be met. If you want the new pod to be scheduled on the node you edited, use the same key and value parameters as the label in the node:

      1.       preferredDuringSchedulingIgnoredDuringExecution:
      2.       - weight: 1
      3.         preference:
      4.           matchExpressions:
      5.           - key: e2e-az-name
      6.             operator: In
      7.             values:
      8.             - e2e-az3

  1. Specify an operator. The operator can be In, NotIn, Exists, DoesNotExist, Lt, or Gt. For example, use the operator In to require the label to be in the node.

  2. Create the pod.

    1. $ oc create -f e2e-az3.yaml

Examples

The following examples demonstrate node affinity.

Node Affinity with Matching Labels

The following example demonstrates node affinity for a node and pod with matching labels:

  • The Node1 node has the label zone:us:

    1. $ oc label node node1 zone=us

  • The pod pod-s1 has the zone and us key/value pair under a required node affinity rule:

    1. $ cat pod-s1.yaml
    2. apiVersion: v1
    3. kind: Pod
    4. metadata:
    5.   name: pod-s1
    6. spec:
    7.   containers:
    8.     - image: "docker.io/ocpqe/hello-pod"
    9.       name: hello-pod
    10.   affinity:
    11.     nodeAffinity:
    12.       requiredDuringSchedulingIgnoredDuringExecution:
    13.         nodeSelectorTerms:
    14.           - matchExpressions:
    15.             - key: "zone"
    16.               operator: In
    17.               values:
    18.               - us

  • Create the pod using the standard command:

    1. $ oc create -f pod-s1.yaml
    2. pod "pod-s1" created

  • The pod pod-s1 can be scheduled on Node1:

    1.  oc get pod -o wide
    2. NAME     READY     STATUS       RESTARTS   AGE      IP      NODE
    3. pod-s1   1/1       Running      0          4m       IP1     node1

Node Affinity with No Matching Labels

The following example demonstrates node affinity for a node and pod without matching labels:

  • The Node1 node has the label zone:emea:

    1. $ oc label node node1 zone=emea

  • The pod pod-s1 has the zone and us key/value pair under a required node affinity rule:

    1. $ cat pod-s1.yaml
    2. apiVersion: v1
    3. kind: Pod
    4. metadata:
    5.   name: pod-s1
    6. spec:
    7.   containers:
    8.     - image: "docker.io/ocpqe/hello-pod"
    9.       name: hello-pod
    10.   affinity:
    11.     nodeAffinity:
    12.       requiredDuringSchedulingIgnoredDuringExecution:
    13.         nodeSelectorTerms:
    14.           - matchExpressions:
    15.             - key: "zone"
    16.               operator: In
    17.               values:
    18.               - us

  • The pod pod-s1 cannot be scheduled on Node1:

    1. oc describe pod pod-s1
    2. <---snip--->
    3. Events:
    4.  FirstSeen LastSeen Count From              SubObjectPath  Type                Reason
    5.  --------- -------- ----- ----              -------------  --------            ------
    6.  1m        33s      8     default-scheduler Warning        FailedScheduling    No nodes are available that match all of the following predicates:: MatchNodeSelector (1).