Automatisch skalierte Knotenattribute mit benutzerdefinierten ComputeClasses steuern

In diesem Dokument erfahren Sie, wie Sie die Compute-Infrastruktur und das Autoscaling-Verhalten von GKE-Clustern (Google Kubernetes Engine) mithilfe von benutzerdefinierten ComputeClasses an die spezifischen Anforderungen Ihrer Arbeitslasten anpassen.

Dieses Dokument richtet sich an Plattformadministratoren, die Autoscaling-Profile für Knoten deklarativ definieren möchten, sowie an Clusteroperatoren, die ihre Arbeitslasten in bestimmten ComputeClasses ausführen möchten.

Benutzerdefinierte ComputeClasses

Benutzerdefinierte ComputeClasses sind benutzerdefinierte Ressourcen von Kubernetes, mit denen Sie Prioritäten definieren können, die GKE bei der Bereitstellung von Knoten zum Ausführen Ihrer Arbeitslasten befolgen soll. Mit einer benutzerdefinierten ComputeClass können Sie Folgendes tun:

  • Weisen Sie GKE eine Reihe von Prioritäten zu, die bei der Bereitstellung von Knoten nacheinander befolgt werden, jeweils mit spezifischen Parametern wie einer Compute Engine-Maschinenserie oder einer minimalen Ressourcenkapazität
  • Autoscaling-Grenzwerte und ‑Parameter definieren, um nicht ausreichend genutzte Knoten zu entfernen und Arbeitslasten effizient auf der vorhandenen Rechenkapazität zu konsolidieren
  • GKE anweisen, weniger bevorzugte Knotenkonfigurationen automatisch durch bevorzugtere Knotenkonfigurationen zu ersetzen, um die Arbeitslastleistung zu optimieren

Informationen zu allen Konfigurationsoptionen und ihrer Interaktion miteinander sowie mit dem GKE Autopilot-Modus und dem GKE Standard-Modus finden Sie unter Benutzerdefinierte ComputeClasses.

Preise

Die benutzerdefinierte Ressource ComputeClass wird ohne zusätzliche Kosten in GKE zur Verfügung gestellt. Dabei gelten folgende Preisaspekte:

Beschränkungen

Der Name Ihrer ComputeClass darf nicht mit gke oder autopilot beginnen.

Hinweis

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

  • Aktivieren Sie die Google Kubernetes Engine API.
    • Google Kubernetes Engine API aktivieren
  • Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem Befehl gcloud components update ab. Ältere gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.
  • Sie benötigen einen GKE-Cluster, auf dem Version 1.30.3-gke.1451000 oder höher ausgeführt wird. Weitere Informationen finden Sie unter Autopilot-Cluster erstellen.

  • Wenn Sie einen Cluster im Standardmodus verwenden, muss eine der folgenden Anforderungen erfüllt sein:

Beispielszenario für ComputeClasses

In diesem Dokument wird ein Beispielszenario vorgestellt, für das Sie eine benutzerdefinierte ComputeClass definieren. In der Praxis sollten Sie die Anforderungen Ihrer spezifischen Arbeitslasten und Ihrer Organisation berücksichtigen und ComputeClasses definieren, die diesen Anforderungen entsprechen. Ausführliche Beschreibungen aller Optionen für ComputeClasses und besondere Hinweise finden Sie unter Benutzerdefinierte ComputeClasses.

Betrachten Sie das folgende Beispielszenario:

  • Ihr Ziel ist es, die laufenden Kosten für Ihre Arbeitslasten zu optimieren
  • Ihre Arbeitslasten sind fehlertolerant und erfordern kein ordnungsgemäßes Herunterfahren oder erweiterte Laufzeit
  • Ihre Arbeitslasten benötigen mindestens 64 vCPUs, um optimal zu funktionieren.
  • Sie sind auf die N4 Compute Engine-Maschinenserie beschränkt

Basierend auf dem Beispielszenario entscheiden Sie sich für eine ComputeClass, die Folgendes ausführt:

  • N4-Spot-Knoten mit mindestens 64 vCPUs werden priorisiert.
  • Ermöglicht GKE unabhängig von der Rechenkapazität ein Fallback auf einen beliebigen N4-Spot-Knoten auszuführen.
  • Wenn keine N4-Spot-Knoten verfügbar sind, lässt sich GKE dazu veranlassen, On-Demand-N4-Knoten zu verwenden.
  • GKE wird angewiesen, Ihre Arbeitslasten auf Spot-Knoten zu verschieben, sobald diese wieder verfügbar sind.

ComputeClass im Autopilot-Modus konfigurieren

In GKE Autopilot definieren Sie eine ComputeClass, stellen sie im Cluster bereit und fordern sie in Ihren Arbeitslasten an. GKE führt alle Knotenkonfigurationsschritte wie das Anwenden von Labels und Markierungen für Sie aus.

Speichern Sie das folgende Manifest als compute-class.yaml:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 64
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

ComputeClass im Standardmodus konfigurieren

In Clustern im GKE-Standardmodus müssen Sie möglicherweise eine manuelle Konfiguration ausführen, damit die Pods Ihrer ComputeClass wie erwartet geplant werden. Die manuelle Konfiguration hängt davon ab, ob Ihre Knotenpools automatisch erstellt werden:

So lassen Sie GKE automatisch Knotenpools für Ihre ComputeClass erstellen:

  1. Aktivieren Sie die automatische Knotenbereitstellung auf Clusterebene für Cluster im Standardmodus, auf denen eine Version vor 1.33.3-gke.1136000 ausgeführt wird und die nicht für die Release-Version „Rapid“ registriert sind.

  2. Speichern Sie das folgende Beispielmanifest als compute-class.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 64
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

    Wenn Sie Pods bereitstellen, für die diese Beispiel-ComputeClass angefordert wird und neue Knoten erstellt werden müssen, priorisiert GKE das Erstellen von Knoten in der Reihenfolge der Elemente im Feld priorities. Bei Bedarf erstellt GKE neue Knotenpools, die die Hardwareanforderungen der ComputeClass erfüllen.

Sie können in Ihren Prioritäten auch einen genauen benutzerdefinierten Maschinentyp angeben. Für die Verwendung benutzerdefinierter Maschinentypen ist die GKE-Version 1.33.2-gke.1111000 oder höher erforderlich. Im folgenden Beispiel wird eine ComputeClass konfiguriert, die Spot-VMs für den benutzerdefinierten Maschinentyp n4-custom-8-20480 priorisiert und auf On-Demand-VMs desselben Typs zurückgreift, wenn keine Spot-Kapazität verfügbar ist:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: custom-machine-type
spec:
  priorities:
  - machineType: n4-custom-8-20480
    spot: true
  - machineType: n4-custom-8-20480
    spot: false
  nodePoolAutoCreation:
    enabled: true

Wenn Sie die Kapazitätsverfügbarkeit bei Kapazitätsengpässen optimieren möchten, definieren Sie eine ComputeClass, die mehrere Maschinenserien und -generationen umfasst. Für zustandslose oder störungstolerante Arbeitslasten können Sie auch die aktive Migration aktivieren, um Arbeitslasten auf Ihre bevorzugte Hardware zurückzuführen, wenn die Kapazität wiederhergestellt ist:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: multi-family-fallback
spec:
  priorities:
  - machineFamily: c4d
  - machineFamily: c3d
  - machineFamily: c4
  - machineFamily: c3
  - machineFamily: n4
  - machineFamily: n2d
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

Neuere Maschinenserien wie C4, C4D und N4 unterstützen nur Hyperdisk, während ältere Serien wie N2D Persistent Disk verwenden. Wenn zustandsorientierte Arbeitslasten eine ComputeClass verwenden, die beide Generationen umfasst, deaktivieren Sie die aktive Migration und verwenden Sie in GKE-Version 1.35.3-gke.1290000 und höher die integrierte StorageClass dynamic-rwo oder eine benutzerdefinierte StorageClass mit automatischer Auswahl des Laufwerkstyps (parameters.type: dynamic), use-allowed-disk-topology: "true" und volumeBindingMode: WaitForFirstConsumer. GKE wählt dann einen kompatiblen Laufwerkstyp aus, wenn neue Volumes bereitgestellt werden, und plant vorhandene Volumes nur auf kompatiblen Maschinenserien.

ComputeClasses mit manuell erstellten Knotenpools verwenden

In diesem Abschnitt erfahren Sie, wie Sie eine ComputeClass in einem Cluster definieren, in dem nur manuell erstellte Knotenpools verwendet werden.

  1. Speichern Sie das folgende Manifest als compute-class.yaml:

    apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 64
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true

  2. Erstellen Sie einen neuen automatisch skalierten Knotenpool, der Spot-VMs verwendet, und verknüpfen Sie ihn mit der ComputeClass:

    gcloud container node-pools create cost-optimized-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n4-standard-64 \
    --spot \
    --enable-autoscaling \
    --max-nodes=9 \
    --node-labels="cloud.google.com/compute-class=cost-optimized" \
    --node-taints="cloud.google.com/compute-class=cost-optimized:NoSchedule"

    Ersetzen Sie Folgendes:

    • LOCATION: Der Standort Ihres Clusters.
    • CLUSTER_NAME ist der Name Ihres vorhandenen Clusters.

  3. Erstellen Sie einen neuen automatisch skalierten Knotenpool mit On-Demand-VMs und verknüpfen Sie ihn mit der ComputeClass:

    gcloud container node-pools create on-demand-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n4-standard-64 \
    --enable-autoscaling \
    --max-nodes=9 \
    --num-nodes=0 \
    --node-labels="cloud.google.com/compute-class=cost-optimized" \
    --node-taints="cloud.google.com/compute-class=cost-optimized:NoSchedule"

Wenn Sie Pods bereitstellen, die diese ComputeClass anfordern und neue Knoten erstellt werden müssen, priorisiert GKE das Erstellen von Knoten im Knotenpool cost-optimized-pool. Wenn keine neuen Knoten erstellt werden können, erstellt GKE Knoten im Knotenpool on-demand-pool.

Weitere Informationen zur Interaktion von manuell erstellten Knotenpools mit benutzerdefinierten ComputeClasses finden Sie unter Manuell erstellte Knotenpools für die Verwendung von ComputeClasses konfigurieren.

Autoscaling-Grenzwerte für die Knotenkonsolidierung anpassen

Standardmäßig entfernt GKE nicht ausgelastete Knoten und verschiebt Ihre Arbeitslasten auf andere verfügbare Knoten. Sie können die Grenzwerte und die Zeitspanne, nach der ein Knoten zum Entfernen vorgeschlagen wird, weiter anpassen. Verwenden Sie dazu das Feld autoscalingPolicy in der ComputeClass-Definition, wie im folgenden Beispiel:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n4
    spot: true
    minCores: 64
  - machineFamily: n4
    spot: true
  - machineFamily: n4
    spot: false
  activeMigration:
    optimizeRulePriority: true
  autoscalingPolicy:
    consolidationDelayMinutes : 5
    consolidationThreshold    : 70

In diesem Beispiel wird ein Knoten zum Entfernen vorgeschlagen, wenn er länger als fünf Minuten zu weniger als 70% seiner verfügbaren CPU- und Arbeitsspeicherkapazität ausgelastet ist. Eine Liste der verfügbaren Parameter finden Sie unter Autoscaling-Parameter für die Knotenkonsolidierung festlegen.

ComputeClass in einem Cluster bereitstellen

Nachdem Sie eine ComputeClass definiert haben, können Sie sie im Cluster bereitstellen:

kubectl apply -f compute-class.yaml

Diese ComputeClass kann im Cluster verwendet werden. Sie können die ComputeClass in Pod-Spezifikationen anfordern oder sie optional als Standard-ComputeClass in einem bestimmten Namespace festlegen.

ComputeClass in einer Arbeitslast anfordern

Wenn Sie eine ComputeClass in einer Arbeitslast anfordern möchten, fügen Sie Ihrem Manifest eine Knotenauswahl für diese ComputeClass hinzu, wie in den folgenden Schritten beschrieben:

  1. Speichern Sie das folgende Manifest als cc-workload.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: custom-workload
spec:
  replicas: 2
  selector:
    matchLabels:
      app: custom-workload
  template:
    metadata:
      labels:
        app: custom-workload
    spec:
      nodeSelector:
        cloud.google.com/compute-class: cost-optimized
      containers:
      - name: test
        image: registry.k8s.io/pause
        resources:
          requests:
            cpu: 1.5
            memory: "4Gi"

  2. Arbeitslast bereitstellen:

    kubectl apply -f cc-workload.yaml

Wenn Sie diese Arbeitslast bereitstellen, fügt GKE den Pods automatisch eine Toleranz hinzu, die der Knotenmarkierung für die angeforderte ComputeClass entspricht. Diese Toleranz sorgt dafür, dass nur Pods, die die ComputeClass anfordern, auf ComputeClass-Knoten ausgeführt werden.

Knoten nach ComputeClass filtern

Alle Knoten, die mit ComputeClasses verknüpft sind, haben das Label cloud.google.com/compute-class.

Führen Sie den folgenden Befehl aus, um alle Knoten aufzurufen, die mit einer bestimmten ComputeClass verknüpft sind:

kubectl get nodes -l cloud.google.com/compute-class=COMPUTECLASS_NAME

Ersetzen Sie COMPUTECLASS_NAME durch den Namen der ComputeClass (z. B. cost-optimized).

Die Ausgabe sieht etwa so aus:

NAME                                                  STATUS   ROLES    AGE   VERSION
gke-cluster-1-cost-optimized-pool-f213e529-rx7d       Ready    <none>   5m    v1.32.4-gke.1236007
gke-cluster-1-cost-optimized-pool-f213e529-ab12       Ready    <none>   5m    v1.32.4-gke.1236007

Führen Sie den folgenden Befehl aus, um alle Knoten im Cluster aufzurufen, die mit einer ComputeClass verknüpft sind:

kubectl get nodes -L cloud.google.com/compute-class

Bereitgestellte ComputeClass aktualisieren

Wenn Sie eine bereitgestellte ComputeClass aktualisieren möchten, ändern Sie das YAML-Manifest für die ComputeClass. Stellen Sie dann das geänderte Manifest mit dem folgenden Befehl bereit:

kubectl apply -f PATH_TO_FILE

Ersetzen Sie PATH_TO_FILE durch den Pfad zu Ihrem geänderten Manifest. Der Wert im Feld name darf nicht geändert werden.

Wenn Sie die aktualisierte ComputeClass bereitstellen, verwendet GKE die aktualisierte Konfiguration, um neue Knoten zu erstellen. Die GKE ändert keine vorhandenen Knoten mit Ihrer aktualisierten Konfiguration.

Im Laufe der Zeit kann GKE vorhandene Pods auf Knoten verschieben, die Ihre aktualisierte Konfiguration verwenden, wenn die ComputeClass die aktive Migration verwendet und die vorhandenen Pods für die Migration infrage kommen.

Nächste Schritte