Automatisch skalierte Knotenattribute mit benutzerdefinierten ComputeClasses steuern

In diesem Dokument erfahren Sie, wie Sie die Compute-Infrastruktur und das automatische Skalieren von GKE-Clustern (Google Kubernetes Engine) mithilfe von benutzerdefinierten Compute-Klassen 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 Compute-Klassen ausführen möchten.

Benutzerdefinierte Compute-Klassen

Benutzerdefinierte Compute-Klassen 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. Sie können eine benutzerdefinierte Compute-Klasse für Folgendes verwenden:

  • 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 Compute-Klassen.

Preise

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

  • GKE Autopilot-Modus: Die Abrechnung erfolgt nach dem netzwerkbasierten Abrechnungsmodell. Weitere Informationen finden Sie unter Autopilot-Modus<. Preise.

  • GKE Standard-Modus: Preise für den Standardmodus

Beschränkungen

Der Name Ihrer Compute-Klasse 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, installieren und dann initialisieren Sie die gcloud CLI. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem gcloud components update Befehl 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, müssen Sie eine der folgenden Anforderungen erfüllen:

Beispielszenario für Compute-Klassen

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

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 Compute-Klasse, die Folgendes ausführt:

  • N4-Spotknoten mit mindestens 64 vCPU werden priorisiert.
  • Ermöglicht GKE unabhängig von der Rechenkapazität ein Fallback auf einen beliebigen N4-Spot-Knoten auszuführen.
  • Wenn keine N4-Spotknoten 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.

Compute-Klasse im Autopilot-Modus konfigurieren

In GKE Autopilot definieren Sie eine Compute-Klasse, 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

Compute-Klasse im Standardmodus konfigurieren

In Clustern im GKE-Standardmodus müssen Sie möglicherweise eine manuelle Konfiguration vornehmen, damit die Pods der Compute-Klasse 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 Compute-Klasse erstellen:

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

  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, die diese Beispiel-Compute-Klasse anfordern 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 Compute-Klasse erfüllen.

Sie können in Ihren Prioritäten auch einen genauen benutzerdefinierten Maschinentyp angeben. Für die Verwendung benutzerdefinierter Maschinentypen ist GKE-Version 1.33.2-gke.1111000 oder höher erforderlich. Im folgenden Beispiel wird eine Compute-Klasse 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

Compute-Klassen mit manuell erstellten Knotenpools verwenden

In diesem Abschnitt erfahren Sie, wie Sie eine Compute-Klasse 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 Compute-Klasse:

    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: Der Name Ihres vorhandenen Clusters.

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

    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 Compute-Klasse 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 Compute-Klassen finden Sie unter Manuell erstellte Knotenpools für die Verwendung von Compute-Klassen 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 den Zeitpunkt, nach dem ein Knoten zum Entfernen vorgeschlagen wird, weiter anpassen. Verwenden Sie dazu das Feld autoscalingPolicy in der Compute-Klassendefinition, 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.

Compute-Klasse in einem Cluster bereitstellen

Nachdem Sie eine Compute-Klasse definiert haben, können Sie sie im Cluster bereitstellen:

kubectl apply -f compute-class.yaml

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

Compute-Klasse in einer Arbeitslast anfordern

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

  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 Compute-Klasse entspricht. Diese Toleranz sorgt dafür, dass nur Pods, die die Compute-Klasse anfordern, auf Compute-Klassenknoten ausgeführt werden.

Knoten nach Compute-Klasse filtern

Alle Knoten, die mit Compute-Klassen 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 Compute-Klasse verknüpft sind:

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

Ersetzen Sie COMPUTECLASS_NAME durch den Namen der Compute-Klasse (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 Compute-Klasse verknüpft sind:

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

Bereitgestellte Compute-Klasse aktualisieren

Wenn Sie eine bereitgestellte Compute-Klasse aktualisieren möchten, ändern Sie das YAML-Manifest für die Compute-Klasse. 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. Achten Sie darauf, dass der Wert im Feld name unverändert bleibt.

Wenn Sie Ihre aktualisierte Compute-Klasse bereitstellen, verwendet GKE Ihre aktualisierte Konfiguration, um neue Knoten zu erstellen. GKE ändert keine vorhandenen Knoten mit Ihrer aktualisierten Konfiguration.

Im Laufe der Zeit verschiebt GKE möglicherweise vorhandene Pods zu Knoten, die Ihre aktualisierte Konfiguration verwenden, wenn die Compute-Klasse die aktive Migration verwendet und wenn die vorhandenen Pods für die Migration infrage kommen.

Nächste Schritte