Node-Affinity in Kubernetes verwenden

Die Knotenaffinität ist ein Satz von Regeln. Sie wird vom Scheduler verwendet, um zu entscheiden, wo ein Pod im Cluster platziert werden kann. Die Regeln werden mit Hilfe von Labels auf Knoten und Label-Selektoren 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, auf denen er terminiert werden kann. Wir können einen Pod so einschränken, dass er nur auf einem oder mehreren bestimmten Knoten laufen 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 jede der angegebenen Bezeichnungen haben.

Die Knotenaffinität ist konzeptionell ähnlich wie nodeSelector – sie ermöglicht es uns, die Knoten einzuschränken, für die unser Pod auf der Grundlage von Labels auf dem Knoten terminiert werden kann.

Derzeit gibt es zwei Arten von Knotenaffinität,

  1. requiredDuringSchedulingIgnoredDuringExecution und
  2. preferredDuringSchedulingIgnoredDuringExecution.

Was ist währendScheduling

  • Hier ist der Pod noch nicht erstellt und wird zum ersten Mal erstellt.
  • Normalerweise werden bei der Erstellung des Pods die Affinitätsregeln angewendet.

Was ist während der Ausführung

  • Hier ist der Pod ausgeführt worden, und die Änderung wird in der Umgebung vorgenommen, die nodeAffinity betrifft.

Um die Knotenaffinität im Detail zu kennen, besuchen Sie kubernete.io, die offizielle Dokumentation von Kubernetes.

In diesem Artikel sehen wir, wie ein Kubernetes-Pod einem bestimmten Knoten unter Verwendung der Knotenaffinität „requiredDuringSchedulingIgnoredDuringExecution“ in einem Kubernetes-Cluster zugewiesen wird.

Vorraussetzungen

  1. Kubernetes Cluster mit mindestens 1 Worker-Knoten.
    Wenn Sie lernen möchten, wie man einen Kubernetes-Cluster erstellt, klicken Sie hier. Dieses Handbuch hilft Ihnen, einen Kubernetes-Cluster mit 1 Master- und 2 Worker-Knoten auf AWS Ubuntu 18.04 EC2-Instanzen zu erstellen.

Was werden wir tun?

  1. Knoten-Affinität konfigurieren

Knoten-Affinität konfigurieren

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

kubectl get nodes #Get all the nodes in the cluster

Prüfen Sie, ob auf den Knoten Taints vorhanden sind.

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

describe-nodes-and-check-taints

Hinzufügen eines Labels zu einem Worker-Knoten node01.

kubectl label node node01 app=qa #Add a label

Etikett zu Knoten hinzufügen1

Erstellen Sie eine Bereitstellungsdefinitionsdatei und fügen Sie darin 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

einsatz - ohne Affinität

Erhalten Sie eine Liste von Pods und Einsätzen.

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

schaffe-Einsatz-ohne-Affinität

Informieren Sie sich über die durch den Einsatz erstellten Pods.

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

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

check-nodes-on-was-wäre-werden-platziert

Erstellen Sie nun eine Bereitstellungsdefinition, in der die Knotenaffinität definiert ist.

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

einsatzbereit-mit-Affinität

Besorgen Sie sich eine Liste der vorhandenen Bereitstellung und erstellen Sie eine neue Bereitstellung mit Affinität unter Verwendung der im obigen Schritt erstellten Datei.

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

schaffe-Einsatz-mit-Affinität

Jetzt ist zu sehen, dass die Pods diesmal nur auf dem Worker-Knoten node01 platziert wurden. Der Grund dafür ist, dass wir in der Einsatzdefinition eine Knotenaffinität definiert haben, die sicherstellt, dass die Pods auf den Knoten eingesetzt werden, die der definierten Bedingung/Beschriftung 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

check-nodes-on-was-geht-werden-platziert

Schlussfolgerung

In diesem Artikel lernten wir das Hinzufügen von Labels zu Knoten und sahen, wie Pods eingeschränkt werden können, um mit Hilfe der Knotenaffinität auf den erforderlichen Knoten terminiert zu werden. Wir haben auch gesehen, dass die Pods sogar auf dem Master-Knoten eingesetzt werden können, wenn dieser kein Taint hat.

Das könnte dich auch interessieren …