0Pricing
DevOps Bootcamp · Lektion

Node-Selektoren und Affinität

Steuern Sie mithilfe von Node-Selektoren sowie ausdrucksstärkeren Node- und Pod-Affinitätsregeln, auf welchen Nodes Pods eingeplant werden.

Node-Selektoren und Affinität ist eine kostenlose DevOps Bootcamp-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des DevOps Bootcamp-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Steuern, wo Pods platziert werden

Standardmäßig plant Kubernetes Pods auf jedem verfügbaren Node ein. Was aber, wenn Sie mehr Kontrolle benötigen?

Manchmal müssen Pods auf bestimmten Nodes ausgeführt werden. Vielleicht verfügen diese Nodes über spezielle Hardware oder Lizenzen oder befinden sich in bestimmten Verfügbarkeitszonen.

In dieser Lektion erfahren Sie, wie Sie den Scheduler von Kubernetes mithilfe von Node Selectors und Node Affinity steuern.

Warum sollte der Scheduler gesteuert werden?

Stellen Sie sich vor, Sie haben einen Datenbank-Pod, der auf einem Node mit leistungsstarken SSDs ausgeführt werden muss, oder eine GPU-intensive Anwendung, die spezielle Hardware benötigt.

Vielleicht möchten Sie bestimmte Pods aus Gründen der Fehlertoleranz voneinander getrennt halten oder sicherstellen, dass sie auf Nodes mit bestimmten Betriebssystemen ausgeführt werden.

Kubernetes stellt Werkzeuge bereit, mit denen Sie solche Planungspräferenzen ausdrücken können.

Nodes haben Labels

Bevor wir Pods an bestimmte Orte schicken können, benötigen Nodes Identitäten! Kubernetes verwendet Labels, um Nodes anhand ihrer Eigenschaften zu identifizieren.

  • Labels sind Schlüssel-Wert-Paare wie disk=ssd oder gpu=true.
  • Sie können Ihren Nodes mithilfe von kubectl label nodes <node-name> <key>=<value> benutzerdefinierte Labels hinzufügen.
  • Anhand dieser Labels wählen wir bestimmte Nodes für die Platzierung von Pods aus.

Node Selectors: Einfache Übereinstimmung

Die einfachste Möglichkeit, einen Pod auf eine bestimmte Gruppe von Nodes zu beschränken, ist die Verwendung von nodeSelector.

Dieses Feld in der Spezifikation Ihres Pods enthält eine Zuordnung von Schlüssel-Wert-Paaren. Der Pod wird nur auf Nodes eingeplant, die alle diese Labels besitzen.

Das ist, als würden Sie sagen: „Ich benötige einen Node, der genau diese Eigenschaften hat.“

Node Selector in Aktion

Nehmen wir an, unsere Nodes sind mit disk=ssd gekennzeichnet. So lassen Sie einen Pod nur auf diesen Nodes ausführen:

apiVersion: v1
kind: Pod
metadata:
  name: ssd-app
spec:
  containers:
  - name: my-container
    image: nginx
  nodeSelector:
    disk: ssd

Node Affinity: Erweiterte Übereinstimmung

nodeSelector ist zwar unkompliziert, aber sehr strikt. Was ist, wenn Sie „bevorzugte“ Nodes oder komplexere Regeln für die Übereinstimmung benötigen?

Node Affinity bietet mehr Flexibilität. Damit können Sie „weiche“ oder „harte“ Anforderungen formulieren, damit Pods auf Nodes mit bestimmten Labels platziert werden.

Dafür wird eine leistungsfähigere Syntax mit Operatoren wie In, NotIn, Exists, DoesNotExist, Gt und Lt verwendet.

Erforderliche und bevorzugte Affinity

Node Affinity gibt es in zwei Hauptformen:

  • requiredDuringSchedulingIgnoredDuringExecution: Der Pod muss auf einem Node eingeplant werden, der die Regeln erfüllt. Wenn kein solcher Node existiert, wird der Pod nicht eingeplant.
  • preferredDuringSchedulingIgnoredDuringExecution: Der Scheduler versucht, einen Node zu finden, der die Regeln erfüllt. Wenn kein solcher Node verfügbar ist, wird der Pod trotzdem an anderer Stelle eingeplant. Dies ist ein „Best Effort“-Ansatz.

Erforderliche Node Affinity

Hier ist ein Pod, der einen Node mit dem Label env=production voraussetzt. Wenn kein solcher Node existiert, bleibt der Pod im Status „Pending“.

apiVersion: v1
kind: Pod
metadata:
  name: prod-app
spec:
  containers:
  - name: my-container
    image: httpd
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: env
            operator: In
            values:
            - production

Pod Affinity: Andere Pods sind relevant

Was ist, wenn Sie Pods danach einplanen möchten, wo andere Pods ausgeführt werden?

  • Pod Affinity: Zieht Pods zu Nodes, auf denen andere Pods mit bestimmten Labels bereits ausgeführt werden. Das ist nützlich, um Dienste gemeinsam zu platzieren, die häufig miteinander kommunizieren.
  • Pod Anti-affinity: Hält Pods von Nodes fern, auf denen andere Pods mit bestimmten Labels ausgeführt werden. Das eignet sich hervorragend, um Replikate für eine hohe Verfügbarkeit über mehrere Nodes zu verteilen.

Pod Anti-affinity in der Praxis

Dieses Manifest stellt sicher, dass keine zwei Pods mit dem Label app=my-web auf demselben Node eingeplant werden können. Das verbessert die Fehlertoleranz.

Der topologyKey legt den Bereich fest, für den die Anti-affinity gilt (z. B. Node oder Zone).

apiVersion: v1
kind: Pod
metadata:
  name: web-app-pod
  labels:
    app: my-web
spec:
  containers:
  - name: web-container
    image: busybox
    command: ["sh", "-c", "echo 'Hello from web-app'; sleep 3600"]
  affinity:
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        - labelSelector:
            matchLabels:
              app: my-web
          topologyKey: "kubernetes.io/hostname"

Testen Sie Ihr Wissen

Sie möchten sicherstellen, dass Ihre kritischen Datenbank-Pods nicht auf Nodes mit dem Label zone=dev eingeplant werden. Welche Art von Planungsregel würden Sie für diesen strikten Ausschluss anhand von Node-Labels verwenden?

Zusammenfassung: Steuerung der Pod-Platzierung

Sehr gut! Sie haben leistungsfähige Möglichkeiten kennengelernt, zu steuern, wo Ihre Pods ausgeführt werden:

  • Node Labels: Schlüssel-Wert-Paare zur Identifizierung von Node-Eigenschaften.
  • Node Selectors: Einfache, strikte Übereinstimmung, um Pods auf Nodes mit bestimmten Labels einzuplanen.
  • Node Affinity: Flexiblere Regeln (erforderlich oder bevorzugt) für die Auswahl von Nodes mithilfe von Operatoren.
  • Pod Affinity/Anti-affinity: Gemeinsame Platzierung oder Trennung von Pods anhand der Standorte anderer Pods.

Diese Werkzeuge sind entscheidend, um die Ressourcennutzung zu optimieren, Fehlertoleranz sicherzustellen und bestimmte Anforderungen von Anwendungen zu erfüllen.

Häufig gestellte Fragen

Ist die Lektion „Node-Selektoren und Affinität“ kostenlos?

Ja — der vollständige Text von „Node-Selektoren und Affinität“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des DevOps Bootcamp-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der DevOps Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Node-Selektoren und Affinität“?

Steuern Sie mithilfe von Node-Selektoren sowie ausdrucksstärkeren Node- und Pod-Affinitätsregeln, auf welchen Nodes Pods eingeplant werden. Du übst DevOps Bootcamp mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um DevOps Bootcamp zu starten?

Keine Vorkenntnisse erforderlich. DevOps Bootcamp auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Node-Selektoren und Affinität“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser DevOps Bootcamp-Lektion Code schreiben und ausführen?

Ja. Jede DevOps Bootcamp-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Ressourcenanforderungen und -limits
  2. Node-Selektoren und Affinität
  3. Taints und Tolerations
  4. Pod-Priorität und Preemption
← Zurück zu DevOps Bootcamp