Planung mit Node Affinity (Knotenaffinität)

Einführung

In Kubernetes wird die Node Affinity (Knotenaffinität) verwendet, um Pods auf Knoten zu planen, die bestimmten Bedingungen entsprechen. Dies kann genutzt werden, um sicherzustellen, dass Pods auf bestimmten Knotentypen geplant werden oder um die Arbeitslast auf mehreren Knoten zu verteilen. In diesem Lab (Praktikum) werden wir lernen, wie man die Node Affinity verwendet, um Pods auf bestimmten Knoten zu planen.

Skills Graph

Starten des Minikube-Clusters

Bevor Sie Ressourcen erstellen, benötigen Sie einen laufenden Kubernetes-Cluster. Minikube ist eine leichte Kubernetes-Umgebung, die auf Ihrem lokalen Rechner läuft.

1. Navigieren Sie zu Ihrem Arbeitsverzeichnis:

   Öffnen Sie das Terminal und navigieren Sie zum Standard-Projektordner:

   cd /home/labex/project

2. Starten Sie Minikube:

   Starten Sie Minikube, um einen Kubernetes-Cluster zu initialisieren:

   minikube start

   • Dieser Befehl richtet einen Ein-Knoten-Kubernetes-Cluster auf Ihrem lokalen Rechner ein.
   • Minikube kann je nach Leistung Ihres Systems einige Minuten dauern, um zu starten.

3. Verifizieren Sie, dass Minikube läuft:

   Überprüfen Sie den Status des Minikube-Clusters:

   minikube status

   • Suchen Sie nach Komponenten wie kubelet und apiserver, die als Running (Läuft) aufgeführt sind.
   • Wenn der Cluster nicht läuft, führen Sie minikube start erneut aus.

Wenn Sie Probleme beim Starten von Minikube haben, können Sie minikube delete verwenden, um die Umgebung bei Bedarf zurückzusetzen.

Erstellen eines Knotens mit Labels

In diesem Schritt werden wir einen Knoten mit einem Label erstellen, das zur Planung von Pods verwendet wird.

1. Erstellen Sie eine Datei mit dem Namen node-with-label.yaml mit folgendem Inhalt im Verzeichnis /home/labex:

apiVersion: v1
kind: Node
metadata:
  name: minikube
  labels:
    type: web

2. Wenden Sie die Änderungen an:

kubectl apply -f node-with-label.yaml

3. Verifizieren Sie, dass der Knoten erstellt und mit einem Label versehen wurde:

kubectl get nodes --show-labels

Erstellen eines Pods mit Node Affinity (Knotenaffinität)

In diesem Schritt werden wir einen Pod mit einer Node Affinity-Regel erstellen, die sicherstellt, dass er auf einem Knoten mit einem bestimmten Label geplant wird.

1. Erstellen Sie eine Datei mit dem Namen pod-with-node-affinity.yaml mit folgendem Inhalt im Verzeichnis /home/labex:

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-node-affinity
spec:
  containers:
    - name: nginx
      image: nginx:latest
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: type
                operator: In
                values:
                  - web

2. Wenden Sie die Änderungen an:

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

3. Verifizieren Sie, dass der Pod auf dem Knoten mit dem Label type=web geplant wurde:

kubectl get pod pod-with-node-affinity -o wide

Erstellen eines Pods mit Node Anti-Affinity (Knoten-Antiaffinität)

In diesem Schritt werden wir einen Pod mit einer Node Anti-Affinity-Regel erstellen, die sicherstellt, dass er nicht auf einem Knoten mit einem bestimmten Label geplant wird.

1. Erstellen Sie eine Datei mit dem Namen pod-with-node-anti-affinity.yaml mit folgendem Inhalt im Verzeichnis /home/labex:

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-node-anti-affinity
spec:
  containers:
    - name: nginx
      image: nginx:latest
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: type
                operator: NotIn
                values:
                  - web

2. Wenden Sie die Änderungen an:

kubectl apply -f pod-with-node-anti-affinity.yaml

3. Verifizieren Sie, dass der Pod nicht auf dem Knoten mit dem Label type=db geplant wurde:

kubectl get pod pod-with-node-anti-affinity -o wide

Erstellen eines Pods mit Node Affinity (Knotenaffinität) und Node Selector (Knotenselektor)

In diesem Schritt werden wir einen Pod mit einer Node Affinity-Regel und einem Node Selector erstellen, um sicherzustellen, dass er auf einem Knoten mit einem bestimmten Label geplant wird.

1. Erstellen Sie eine Datei mit dem Namen pod-with-node-affinity-and-selector.yaml mit folgendem Inhalt im Verzeichnis /home/labex:

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-node-affinity-and-selector
spec:
  containers:
    - name: nginx
      image: nginx:latest
  nodeSelector:
    type: web
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: type
                operator: In
                values:
                  - db

2. Wenden Sie die Änderungen an:

kubectl apply -f pod-with-node-affinity-and-selector.yaml

3. Verifizieren Sie, dass der Pod nicht auf dem Knoten mit dem Label type=web geplant wurde:

kubectl get pod pod-with-node-affinity-and-selector -o wide

Erstellen eines Pods mit mehreren Node Affinity-Regeln (Knotenaffinitätsregeln)

In diesem Schritt werden wir einen Pod mit mehreren Node Affinity-Regeln erstellen, um sicherzustellen, dass er auf einem Knoten geplant wird, dessen Labels allen Regeln entsprechen.

1. Erstellen Sie eine Datei mit dem Namen pod-with-multiple-node-affinity.yaml mit folgendem Inhalt im Verzeichnis /home/labex:

apiVersion: v1
kind: Pod
metadata:
  name: pod-with-multiple-node-affinity
spec:
  containers:
    - name: nginx
      image: nginx:latest
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: type
                operator: In
                values:
                  - web
          - matchExpressions:
              - key: disktype
                operator: In
                values:
                  - ssd

2. Wenden Sie die Änderungen an:

kubectl apply -f pod-with-multiple-node-affinity.yaml

3. Verifizieren Sie, dass der Pod auf dem Knoten mit den Labels type=web und disktype=ssd geplant wurde:

kubectl get pod pod-with-multiple-node-affinity -o wide

Zusammenfassung

In diesem Lab haben wir gelernt, wie man Node Affinity (Knotenaffinität) verwendet, um Pods auf bestimmten Knoten zu planen. Wir haben einen Knoten mit einem Label erstellt und dann Pods mit Node Affinity-Regeln erstellt, die sicherstellten, dass sie auf Knoten mit bestimmten Labels geplant wurden. Wir haben auch einen Pod mit einer Node Anti-Affinity-Regel (Knoten-Antiaffinitätsregel) erstellt, die sicherstellte, dass er nicht auf einem Knoten mit einem bestimmten Label geplant wurde. Schließlich haben wir einen Pod mit mehreren Node Affinity-Regeln erstellt, der sicherstellte, dass er auf einem Knoten geplant wurde, dessen Labels allen Regeln entsprachen.