Verwenden Sie Knotenaffinität in Kubernetes

Die Knotenaffinität ist eine Reihe von Regeln. Es wird vom Planer verwendet, um zu entscheiden, wo ein Pod im Cluster platziert werden kann. Die Regeln werden mithilfe von Labels auf Knoten und Labelselektoren definiert, die in der Pod-Definition angegeben sind. Die Knotenaffinität ermöglicht es einem Pod, eine Affinität zu einer Gruppe von Knoten anzugeben, für die er geplant werden kann. Wir können einen Pod so einschränken, dass er nur auf einem oder mehreren bestimmten Knoten ausgeführt werden kann.

nodeSelector ist die einfachste Form der Knotenauswahlbeschränkung. nodeSelector ist eine Eigenschaft von PodSpec. Damit der Pod auf einem Knoten ausgeführt werden kann, muss der Knoten jedes der angegebenen Labels haben.

Die Knotenaffinität ist konzeptionell ähnlich wie nodeSelector – sie ermöglicht es uns, basierend auf Labels auf dem Knoten einzuschränken, auf welchen Knoten unser Pod geplant werden kann.

Derzeit gibt es zwei Arten von Knotenaffinität, 

1. requiredDuringSchedulingIgnoredDuringExecution und 
2. preferredDuringSchedulingIgnoredDuringExecution.

Was ist WhileScheduling

• Hier ist der Pod noch nicht erstellt und wird zum ersten Mal erstellt.
• Normalerweise werden die Affinitätsregeln angewendet, wenn der Pod erstellt wird.

Was ist WhileExecution

• Hier wurde der Pod ausgeführt und die Änderung wird in der Umgebung vorgenommen, die sich auf nodeAffinity auswirkt.

Um mehr über Node Affinity im Detail zu erfahren, besuchen Sie kubernet.io, die offizielle Dokumentation von Kubernetes.

In diesem Artikel erfahren Sie, wie Sie einem bestimmten Knoten mithilfe der Knotenaffinität „requiredDuringSchedulingIgnoredDuringExecution“ in einem Kubernetes-Cluster einen Kubernetes-Pod zuweisen.

Voraussetzungen

1. Kubernetes-Cluster mit mindestens einem Worker-Knoten.
   Wenn Sie erfahren möchten, wie Sie einen Kubernetes-Cluster erstellen, klicken Sie hier. Dieser Leitfaden hilft Ihnen beim Erstellen eines Kubernetes-Clusters mit 1 Master und 2 Knoten auf AWS Ubuntu 18.04 EC2-Instances.

Was werden wir tun?

1. Knotenaffinität konfigurieren

Knotenaffinität konfigurieren

Lassen Sie uns zunächst eine Liste der im Cluster verfügbaren Knoten abrufen.

kubectl get nodes #Get all the nodes in the cluster

Überprüfen Sie, ob Knoten Markierungen aufweisen.

kubectl describe node node01 | grep Taints #Describe the node node01 and grep Taints

kubectl describe node master | grep Taints #Describe the node master and grep Taints

Fügen Sie einem Worker-Knoten node01 ein Label hinzu.

kubectl label node node01 app=qa #Add a label

Erstellen Sie eine Bereitstellungsdefinitionsdatei und fügen Sie ihr die folgende Definition hinzu.

vim my-deployment-without-affinity.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-without-affinity
spec:
  replicas: 20
  selector:
    matchLabels:
      run: nginx
  template:
    metadata:
      labels:
        run: nginx
    spec:
      containers:
      - image: nginx
        imagePullPolicy: Always
        name: nginx

Rufen Sie eine Liste der Pods und Bereitstellungen ab.

kubectl get pods #Get pods in the default namespace

kubectl get deployment #Get deployments in the default namespace

Erstellen Sie eine Bereitstellung aus der von uns erstellten Definition.

kubectl create -f my-deployment-without-affinity.yml #Create a deployment object

kubectl get deployment #Get deployments in the default namespace

kubectl get pods #Get pods in the default namespace

Rufen Sie Details zu den Pods ab, die durch die Bereitstellung erstellt wurden.

Hier ist zu sehen, dass die Pods auch Plätze im Masterknoten bekommen. Der Grund dafür ist, dass die Knoten keine Taints haben, sodass Pods auf jedem der verfügbaren Knoten platziert werden können.

kubectl get pods -o wide #Get pods in the default namespace with more information about them using -o wide

Erstellen Sie jetzt eine Bereitstellungsdefinition mit definierter Knotenaffinität.

vim my-deployment-with-affinity.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app-with-afiinity
spec:
  replicas: 6
  selector:
    matchLabels:
      run: nginx
  template:
    metadata:
      labels:
        run: nginx
    spec:
      containers:
      - image: nginx
        imagePullPolicy: Always
        name: nginx
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: app
                operator: In
                values:
                - qa

Rufen Sie eine Liste vorhandener Bereitstellungen ab und erstellen Sie eine neue Bereitstellung mit Affinität, indem Sie die im obigen Schritt erstellte Datei verwenden.

kubectl get deployments #Get deployments in the default namespace

kubectl create -f my-deployment-with-affinity.yml #Create a deployment object

kubectl get deployments #Get deployments in the default namespace

Nun ist ersichtlich, dass die Pods dieses Mal nur auf dem Worker-Knoten node01 platziert wurden. Der Grund dafür ist, dass wir in der Bereitstellungsdefinition eine Knotenaffinität definiert haben, die sicherstellt, dass die Pods auf den Knoten bereitgestellt werden, die der definierten Bedingung/Kennzeichnung entsprechen.

kubectl  get pods -o wide | grep app-with-afiinity #Get pods in the default namespace with more information about them using -o wide and grep app-with-afiinity

Schlussfolgerung

In diesem Artikel haben wir gelernt, Knoten Labels hinzuzufügen, und gesehen, wie Pods mithilfe von Knotenaffinität darauf beschränkt werden können, auf den erforderlichen Knoten geplant zu werden. Wir haben auch gesehen, dass die Pods sogar auf dem Master-Knoten bereitgestellt werden können, wenn dieser keinen Taint enthält.