Pods auf Nodes verteilen

Ziel

In diesem Projekt geht es um den Scheduler und wie Pods auf Nodes verteilt werden. Sie werden:

Node-Selektoren verwenden
Node-Affinity verwenden
Taints und Tolerations testen

Hilfsmittel

Versuchen Sie, die unten stehenden Aufgaben mit Hilfe der Folien und der Cheatsheets eigenständig zu lösen.
Sollten Sie dabei Probleme haben, finden Sie bei jeder Aufgabe einen ausklappbaren Block, in dem der Lösungsweg beschrieben wird.

Aufgabe 1: Kubernetes Scheduling verstehen

Der Kubernetes Scheduler ist für die Zuweisung von Pods zu Nodes verantwortlich. Er berücksichtigt dabei verschiedene Kriterien wie Ressourcenverfügbarkeit, Scheduling-Richtlinien, Affinitäts- und Anti-Affinitätsspezifikationen, Taints und Tolerations.

Erstellen Sie eine Deployment YAML-Datei scheduling.yaml und definieren Sie ein Deployment, das das nginx-Image verwendet und 10 Replikate spezifiziert:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment-scheduling
spec:
  replicas: 10
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx

Wenden Sie die Deployment-Datei an und überprüfen Sie, wie die Pods auf den Nodes verteilt werden

Lösung (Klicken Sie auf den Pfeil, falls Sie nicht weiterkommen)

kubectl apply -f scheduling.yaml
kubectl get deployments
kubectl get pods -o wide

Aufgabe 2: Node-Selektoren verwenden

Node-Selektoren sind eine Möglichkeit, Pods auf bestimmte Nodes zu beschränken. Sie können verwendet werden, um Pods auf Nodes mit bestimmten Eigenschaften zu platzieren.

Aufgabe 2.1: Node mit Labels versehen

Der Training-Cluster hat drei Worker-Nodes, diese Nodes sind alle identisch:

k get nodes

NAME                        STATUS   ROLES           AGE    VERSION
code-0-worker-wppfn-5k28c   Ready    <none>          3d1h   v1.28.6
code-0-worker-wppfn-hx7qs   Ready    <none>          3d1h   v1.28.6
code-0-worker-wppfn-v5vts   Ready    <none>          3d1h   v1.28.6

Für diese Übung werden wir einen von ihnen als node-type=gpu bezeichnen und ein Deployment darauf planen.

Labeln Sie den ersten Node mit node-type=gpu:

kubectl label node <node_name> node-type=gpu

Überprüfen Sie, ob der Node gelabelt wurde:

kubectl get nodes --show-labels

Aufgabe 2.2: Deployment mit Node-Selektor erstellen

Kopieren Sie das Deployment aus Aufgabe 1 in die neue Datei node-selector.yaml und fügen Sie einen Node-Selektor hinzu, um die Pods auf den Node mit dem Label node-type=gpu zu beschränken

Lösung (Klicken Sie auf den Pfeil, falls Sie nicht weiterkommen)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      nodeSelector:
        node-type: gpu
      containers:
      - name: nginx
        image: nginx

Wenden Sie die Deployment-Datei an und überprüfen Sie, wie die Pods auf den Nodes verteilt werden

Lösung (Klicken Sie auf den Pfeil, falls Sie nicht weiterkommen)

kubectl apply -f nodeselector.yaml
kubectl get pods -o wide

Aufgabe 3: Node-Affinity

Node-Affinity ist eine erweiterte Möglichkeit, Pods auf Nodes zu platzieren. Es ermöglicht Ihnen, Regeln zu definieren, die bestimmen, auf welchen Nodes ein Pod geplant werden soll.

Aufgabe 3.1: Deployment mit Node-Affinity

Erstellen Sie eine Deployment-Datei node-affinity.yaml und fügen Sie das folgende Deployment hinzu:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: node-affinity
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.25.4-alpine

Erweitern Sie das Deployment, um eine Node-Affinität zu node-type=gpu zu haben

Lösung (Klicken Sie auf den Pfeil, falls Sie nicht weiterkommen)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gpu-nginx
  labels:
    exercise: node-affinity
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.25.4-alpine
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: node-type
                operator: In
                values:
                - gpu

Wenden Sie das Deployment auf Ihrem Cluster an und beobachten Sie die Verteilung der Pods auf den Nodes

Lösung (Klicken Sie auf den Pfeil, falls Sie nicht weiterkommen)

kubectl apply -f gpu-deployment.yaml

kubectl get pods -o wide

Aufgabe 4: Taints und Tolerations

Aufgabe 4.1: Node tainten

Wir haben bereits ein Label node-type=gpu auf einem Node hinzugefügt. Jetzt werden wir einen Taint hinzufügen, um zu verhindern, dass Pods auf diesem Node geplant werden, es sei denn, sie haben eine Toleration für diesen Taint.

Tainten Sie den ersten Node mit node-type=gpu:

kubectl taint node <node_name> node-type=gpu:NoSchedule

Der Taint ist ein Key-Value-Paar, das auf einem Node angewendet wird. Er wird verwendet, um Pods davon abzuhalten, auf dem Node geplant zu werden, es sei denn, der Pod hat eine passende Toleration.

Aufgabe 4.2: Deployment mit Toleration

Erstellen Sie eine Deployment-Datei toleration.yaml und fügen Sie das folgende Deployment hinzu:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: gpu-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: gpu-app
  template:
    metadata:
      labels:
        app: gpu-app
    spec:
      containers:
      - name: cuda-app
        image: alpine
        command: ["sleep"]
        args: ["infinity"]
      nodeSelector:
        node-type: gpu

Wenden Sie das Deployment auf Ihrem Cluster an und beobachten Sie, wie die Pods auf den Nodes verteilt werden

Der Pod befindet sich im Zustand pending und wird nicht auf einem Node geplant. Das liegt daran, dass die Nodes mit node-type=gpu getaintet sind und die Pods keine Toleranz für diesen Taint haben.

Erweitern Sie das Deployment, um eine Toleranz für den node-type=gpu Taint hinzuzufügen

Lösung (Klicken Sie auf den Pfeil, falls Sie nicht weiterkommen)

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: gpu-app
  labels:
    exercise: taints
spec:
  replicas: 2
  selector:
    matchLabels:
      app: gpu-app
  template:
    metadata:
      labels:
        app: gpu-app
    spec:
      containers:
      - name: cuda-app
        image: alpine
        command: ["sleep"]
        args: ["infinity"]
      nodeSelector:
        node-type: gpu
      tolerations:
      - key: "node-type"
        operator: "Equal"
        value: "gpu"
        effect: "NoSchedule"

Wenden Sie das Deployment auf Ihrem Cluster an und beobachten Sie, wie die Pods auf den Nodes verteilt werden
Nutzen Sie kubectl get pods -o wide um zu überprüfen, dass alle Replikate auf dem gpu Node geplant wurden

Aufgabe 4.3: Taint entfernen

Entfernen Sie den Taint von der Node

kubectl taint node <node_name> node-type:NoSchedule-

Clean Up

Löschen Sie die erstellten Resourcen