Scheduling mit Node Affinity

Einführung

In Kubernetes wird Node Affinity verwendet, um Pods auf Nodes zu planen, die bestimmte Bedingungen erfüllen. Dies kann genutzt werden, um sicherzustellen, dass Pods auf spezifischen Node-Typen ausgeführt werden oder um die Arbeitslast gleichmäßig über Nodes zu verteilen. In diesem Lab lernen wir, wie man Node Affinity einsetzt, um Pods gezielt auf bestimmten Nodes zu platzieren.

Starten des Minikube-Clusters

Bevor Sie Ressourcen erstellen können, benötigen Sie einen laufenden Kubernetes-Cluster. Minikube ist eine leichtgewichtige Kubernetes-Umgebung, die auf Ihrem lokalen Rechner ausgeführt wird.

Navigieren Sie zu Ihrem Arbeitsverzeichnis:

Öffnen Sie das Terminal und wechseln Sie in den Standard-Projektordner:
```
cd /home/labex/project
```
Starten Sie Minikube:

Starten Sie Minikube, um einen Kubernetes-Cluster zu initialisieren:
```
minikube start
```
- Dieser Befehl richtet einen Single-Node-Kubernetes-Cluster auf Ihrem lokalen Rechner ein.
- Je nach Leistung Ihres Systems kann der Start von Minikube einige Minuten in Anspruch nehmen.
Überprüfen Sie, ob Minikube läuft:

Prüfen Sie den Status des Minikube-Clusters:
```
minikube status
```
- Achten Sie darauf, dass Komponenten wie kubelet und apiserver als Running aufgeführt sind.
- Falls der Cluster nicht läuft, führen Sie minikube start erneut aus.

Sollten Probleme beim Starten von Minikube auftreten, verwenden Sie minikube delete, um die Umgebung bei Bedarf zurückzusetzen.

Führen Sie die restlichen Schritte dieses Labs von /home/labex/project aus, damit die YAML-Dateien im selben Arbeitsverzeichnis bleiben.

Erstellen eines Nodes mit Labels

In diesem Schritt erstellen wir einen Node mit einem Label, das später für das Scheduling von Pods verwendet wird.

Erstellen Sie eine Datei namens node-with-label.yaml mit folgendem Inhalt im Verzeichnis /home/labex/project:

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

Wenden Sie die Änderungen an:

kubectl apply -f node-with-label.yaml

Überprüfen Sie, ob der Node erstellt und mit dem Label versehen wurde:

kubectl get nodes --show-labels

Erstellen eines Pods mit Node Affinity

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

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

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

Wenden Sie die Änderungen an:

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

Überprüfen Sie, ob der Pod auf dem Node mit dem Label type=web geplant wurde:

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

Erstellen eines Pods mit Node Anti-Affinity

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

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

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

Wenden Sie die Änderungen an:

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

Überprüfen Sie, ob der Pod nicht auf dem Node mit dem Label type=db geplant wurde:

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

Erstellen eines Pods mit Node Affinity und Node Selector

In diesem Schritt erstellen wir einen Pod, der sowohl eine Node-Affinity-Regel als auch einen Node Selector verwendet, um sicherzustellen, dass er auf einem Node mit einem spezifischen Label geplant wird.

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

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

Wenden Sie die Änderungen an:

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

Überprüfen Sie, ob der Pod nicht auf dem Node 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

In diesem Schritt erstellen wir einen Pod mit mehreren Node-Affinity-Regeln, die sicherstellen, dass er nur auf einem Node geplant wird, dessen Labels alle Regeln erfüllen.

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

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

Wenden Sie die Änderungen an:

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

Überprüfen Sie, ob der Pod auf dem Node 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 verwendet, um Pods auf bestimmten Nodes zu planen. Wir haben einen Node mit einem Label versehen und anschließend Pods mit Node-Affinity-Regeln erstellt, die sicherstellten, dass sie auf Nodes mit den entsprechenden Labels platziert wurden. Zudem haben wir einen Pod mit einer Node-Anti-Affinity-Regel erstellt, um eine Platzierung auf bestimmten Nodes zu verhindern. Abschließend haben wir einen Pod mit mehreren Node-Affinity-Regeln konfiguriert, um sicherzustellen, dass er nur auf Nodes geplant wird, die alle definierten Kriterien erfüllen.