Planung mit Knotenselektoren (Node Selectors)

Einführung

In diesem Lab werden wir zunächst eine einfache Bereitstellung (Deployment) erstellen und dann Knotenselektoren (Node Selectors) zuweisen. Anschließend werden wir uns komplexeren Szenarien widmen, in denen wir verschiedene Selektoren verwenden, um Pods auf bestimmten Knoten zu planen.

Dies ist ein Guided Lab, das schrittweise Anweisungen bietet, um Ihnen beim Lernen und Üben zu helfen. Befolgen Sie die Anweisungen sorgfältig, um jeden Schritt abzuschließen und praktische Erfahrungen zu sammeln. Historische Daten zeigen, dass dies ein Labor der Stufe Anfänger mit einer Abschlussquote von 100% ist. Es hat eine positive Bewertungsrate von 91% von den Lernenden erhalten.

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.

Navigieren Sie zu Ihrem Arbeitsverzeichnis:

Öffnen Sie das Terminal und navigieren Sie zum Standardprojektordner:
```
cd /home/labex/project
```
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.
Überprüfen Sie, ob Minikube läuft:

Überprüfen Sie den Status des Minikube-Clusters:
```
minikube status
```
- Suchen Sie nach Komponenten wie kubelet und apiserver, die als Running 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 einer einfachen Bereitstellung (Deployment)

In diesem Schritt werden wir eine einfache Bereitstellung mit einem einzelnen Pod erstellen.

Erstellen Sie eine Datei mit dem Namen simple-deployment.yaml mit folgendem Inhalt:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: simple-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: simple-app
  template:
    metadata:
      labels:
        app: simple-app
    spec:
      containers:
        - name: simple-container
          image: nginx:latest

Verwenden Sie kubectl, um die Bereitstellung zu erstellen:

kubectl apply -f simple-deployment.yaml

Überprüfen Sie, ob die Bereitstellung erstellt wurde:

kubectl get deployments

Zuweisen von Knotenselektoren (Node Selectors) zu einer Bereitstellung (Deployment)

In diesem Schritt werden wir einem Knotenselektor (Node Selector) der Bereitstellung zuweisen, die wir in Schritt 1 erstellt haben.

Erstellen Sie die Knoten mit einer Bezeichnung (Label):

kubectl label nodes minikube disk=ssd

Bearbeiten Sie die Datei node-selector-deployment.yaml und fügen Sie das Feld nodeSelector unter dem Abschnitt spec.template.spec hinzu:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: selector-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: selector-app
  template:
    metadata:
      labels:
        app: selector-app
    spec:
      nodeSelector:
        disk: ssd
      containers:
        - name: selector-container
          image: nginx:latest

Verwenden Sie kubectl, um die Änderungen anzuwenden:

kubectl apply -f node-selector-deployment.yaml

Überprüfen Sie, ob der Pod auf einem Knoten mit der Bezeichnung disk=ssd geplant wurde:

kubectl get pods -o wide | grep selector-deployment

Verwenden verschiedener Knotenselektoren (Node Selectors)

In diesem Schritt werden wir verschiedene Knotenselektoren (Node Selectors) verwenden, um Pods auf bestimmten Knoten zu planen, basierend auf den Bezeichnungen (Labels), die diesen Knoten zugewiesen wurden.

Erstellen Sie drei Knoten mit verschiedenen Bezeichnungen (Labels):

kubectl label nodes minikube resigon=labex
kubectl label nodes minikube gpu=true

Erstellen Sie eine Datei mit dem Namen multi-selector-deployment.yaml mit folgendem Inhalt:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: multi-selector-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: multi-selector-app
  template:
    metadata:
      labels:
        app: multi-selector-app
    spec:
      containers:
        - name: multi-selector-container
          image: nginx:latest
      nodeSelector:
        resigon: labex
        gpu: "true"

Wenden Sie die Änderungen an:

kubectl apply -f multi-selector-deployment.yaml

Überprüfen Sie, ob die Pods auf Knoten mit den entsprechenden Bezeichnungen (Labels) geplant wurden:

kubectl get pods -o wide | grep multi-selector-deployment

Zusammenfassung

In diesem Lab haben wir gelernt, wie man Pods auf bestimmten Knoten mithilfe von Knotenselektoren (Node Selectors) und Knotenaffinität (Node Affinity) plant. Wir begannen mit einer einfachen Bereitstellung (Deployment) und gingen dann zu komplexeren Szenarien über, in denen wir verschiedene Selektoren und Affinitätsregeln verwendeten, um Pods auf bestimmten Knoten zu planen, basierend auf den Bezeichnungen (Labels), die diesen Knoten zugewiesen wurden.

Herzlichen Glückwunsch! Sie haben dieses Lab erfolgreich abgeschlossen.