Automatisch skalierte Knotenattribute mit benutzerdefinierten Compute-Klassen steuern

Auf dieser Seite 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. Sie sollten mit dem Konzept benutzerdefinierter Compute-Klassen vertraut sein. Weitere Informationen finden Sie unter Benutzerdefinierte Compute-Klassen.

Diese Seite 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. Mit einer benutzerdefinierten Compute-Klasse 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 Computing-Klassen.

Preise

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

Hinweise

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 gcloud components update ab.
  • 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 mindestens ein Knotenpool mit aktiviertem Autoscaling vorhanden sein oder Ihr Cluster muss die automatische Knotenbereitstellung verwenden.

Beispielszenario für Compute-Klassen

Auf dieser Seite 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 N2 Compute Engine-Maschinenserie beschränkt

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

  • N2-Spotknoten mit mindestens 64 vCPU werden priorisiert.
  • Ermöglicht GKE unabhängig von der Rechenkapazität ein Fallback auf einen beliebigen N2-Spot-Knoten auszuführen.
  • Wenn keine N2-Spot-Knoten verfügbar sind, lässt sich GKE dazu veranlassen, On-Demand-N2-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: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    spot: false
  activeMigration:
    optimizeRulePriority: true
  nodePoolAutoCreation:
    enabled: true

Compute-Klasse im Standardmodus konfigurieren

In Clustern im GKE-Standardmodus definieren Sie eine Compute-Klasse. Nach dieser müssen Sie möglicherweise eine manuelle Konfiguration vornehmen, um sicherzustellen, dass die Pods der Compute-Klasse wie erwartet geplant werden. Die manuelle Konfiguration hängt davon ab, ob Ihre Knotenpools automatisch bereitgestellt werden:

  • Knotenpools, die über die automatische Knotenbereitstellung verwaltet werden: Keine manuelle Konfiguration erforderlich. Bei der automatischen Knotenbereitstellung werden die Konfigurationsschritte für die Compute-Klasse automatisch für Sie ausgeführt. Weitere Informationen finden Sie unter Automatische Knotenbereitstellung und Compute-Klassen.
  • Manuell erstellte Knotenpools: Eine manuelle Konfiguration ist erforderlich. Sie müssen Ihren manuell erstellten Knotenpools Knotenlabels und Knotenmarkierungen hinzufügen, um die Knoten einer bestimmten Compute-Klasse zuzuordnen. Weitere Informationen finden Sie unter Manuell erstellte Knotenpools für die Verwendung von Compute-Klassen konfigurieren.

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: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    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=n2-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 Compute-Klasse:

    gcloud container node-pools create on-demand-pool \
    --location=LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=n2-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.

Compute-Klassen mit automatisch bereitgestellten Knotenpools verwenden

In diesem Abschnitt erfahren Sie, wie Sie eine Compute-Klasse in einem Cluster definieren, der die automatische Knotenbereitstellung verwendet.

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

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

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

Weitere Informationen zur Funktionsweise der automatischen Knotenbereitstellung mit benutzerdefinierten Compute-Klassen finden Sie unter Automatische Knotenbereitstellung und Compute-Klassen.

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 Definition der Compute-Klasse, wie im folgenden Beispiel:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: cost-optimized
spec:
  priorities:
  - machineFamily: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    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 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-Standardklasse für einen Namespace festlegen

Wenn Sie eine Standard-Compute-Klasse für einen Namespace festlegen, verwendet GKE diese Compute-Klasse, um Knoten für alle Pods zu erstellen, die Sie in diesem Namespace bereitstellen. Wenn für einen Pod explizit eine andere Compute-Klasse angefordert wird, wird die Standardeinstellung des Namespace durch die Anfrage auf Pod-Ebene überschrieben.

So legen Sie eine Compute-Klasse als Standard für einen bestimmten Namespace fest:

  1. Erstellen Sie einen Namespace:

    kubectl create namespace cost-optimized-ns

  2. Versehen Sie den Namespace mit dem Label der Compute-Klasse:

    kubectl label namespaces cost-optimized-ns \
    cloud.google.com/default-compute-class=cost-optimized

Compute-Klasse in einer Arbeitslast anfordern

Wenn Sie eine Compute-Klasse in einer Arbeitslast anfordern möchten, fügen Sie Ihrem Manifest einen Knotenselektor für diese Compute-Klasse hinzu.

  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: gcr.io/google_containers/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.

Nächste Schritte