Benutzerdefinierte Compute-Klassen

Auf dieser Seite wird beschrieben, wie Sie mithilfe von benutzerdefinierten Compute-Klassen die Attribute der Knoten steuern können, die Google Kubernetes Engine (GKE) beim Autoscaling Ihres Clusters bereitstellt. Dieses Dokument richtet sich an Plattformadministratoren, die Autoscaling-Profile für Knoten deklarativ definieren möchten, damit bestimmte Arbeitslasten auf Hardware ausgeführt werden, die ihren Anforderungen entspricht.

Compute-Klassen – Übersicht

In GKE ist eine Compute-Klasse ein Profil, das aus einer Reihe von Knotenattributen besteht, mit denen GKE die Knoten bereitstellt, auf denen Ihre Arbeitslasten ausgeführt werden. Compute-Klassen können auf bestimmte Optimierungen ausgerichtet werden, z. B. auf die Bereitstellung von Hochleistungsknoten oder die Priorisierung kostenoptimierter Konfigurationen für niedrigere Betriebskosten. Mit benutzerdefinierten Compute-Klassen können Sie Profile definieren, die GKE dann zur Bereitstellung von Knoten verwendet, die die Anforderungen bestimmter Arbeitslasten bestmöglich erfüllen.

Benutzerdefinierte Compute-Klassen stehen für den GKE-Autopilot-Modus und den GKE-Standardmodus in Version 1.30.3-gke.1451000 und höher zur Verfügung und bieten einen deklarativen Ansatz zum Definieren von Knotenattributen und Autoscaling-Prioritäten. Benutzerdefinierte Compute-Klassen können standardmäßig in allen unterstützten GKE-Clustern konfiguriert und verwendet werden.

Vorteile benutzerdefinierter Compute-Klassen

Benutzerdefinierte Compute-Klassen bieten folgende Vorteile:

• Fallback-Computing-Prioritäten: Hiermit können Sie in jeder Computing-Klasse eine Hierarchie von Knotenkonfigurationen definieren, die von GKE priorisiert werden sollen. Wenn die bevorzugte Konfiguration nicht verfügbar ist, wählt GKE automatisch die nächste Konfiguration in der Hierarchie aus. Dieses Fallback-Modell sorgt dafür, dass Ihre Arbeitslasten auch dann auf optimierter Hardware mit minimalen Planungsverzögerungen ausgeführt werden, selbst wenn keine Rechenressourcen verfügbar sind.
• Detaillierte Autoscaling-Steuerung: Sie können Knotenkonfigurationen definieren, die für bestimmte Arbeitslasten am besten geeignet sind. GKE priorisiert diese Konfigurationen beim Erstellen von Knoten während der Skalierung.
• Deklarative Infrastrukturkonfiguration: Nutzen Sie einen deklarativen Ansatz für die Infrastrukturverwaltung, damit GKE automatisch Knoten für Sie erstellt, die Ihren spezifischen Arbeitslastanforderungen entsprechen.
• Aktive Migration: Wenn an Ihrem Standort Rechenressourcen für eine bevorzugte Maschinenkonfiguration verfügbar werden, migriert GKE Ihre Arbeitslasten automatisch auf neue Knoten, die die bevorzugte Konfiguration verwenden.
• Kostenoptimierung: Priorisieren Sie kosteneffiziente Knotentypen wie Spot-VMs, um Ihre Clusterkosten zu reduzieren.
• Standard-Compute-Klassen für Namespaces: Legen Sie in jedem Kubernetes-Namespace eine Standard-Compute-Klasse fest, damit Arbeitslasten in diesem Namespace auf optimierter Hardware ausgeführt werden, auch wenn keine bestimmte Compute-Klasse angefordert wird.
• Benutzerdefinierte Grenzwerte für die Knotenkonsolidierung: Hier können Sie benutzerdefinierte Grenzwerte für die Ressourcennutzung für Knoten festlegen. Wenn die Ressourcennutzung eines bestimmten Knotens unter Ihren Schwellenwert fällt, versucht GKE, die Arbeitslasten zu einem ähnlichen, verfügbaren Knoten zu konsolidieren und den nicht ausgelasteten Knoten herunterzuskalieren.

Anwendungsfälle für benutzerdefinierte Compute-Klassen

Ziehen Sie die Verwendung benutzerdefinierter Compute-Klassen in Szenarien wie den folgenden in Betracht:

• Sie möchten Ihre KI-/ML-Arbeitslasten auf bestimmten GPU-Konfigurationen ausführen.
• Sie möchten Standardhardwarekonfigurationen für die Arbeitslasten festlegen, die von bestimmten Teams ausgeführt werden, um den Overhead für die Anwendungsoperatoren zu reduzieren.
• Sie führen Arbeitslasten aus, die für bestimmte Compute Engine-Maschinenserien oder Hardwarekonfigurationen eine optimale Leistung erzielen.
• Sie möchten Hardwarekonfigurationen angeben, die bestimmten Geschäftsanforderungen entsprechen, z. B. hohe Leistung, kostenoptimiert oder Hochverfügbarkeit.
• Sie möchten, dass GKE bei nicht verfügbaren Rechenressourcen hierarchisch auf bestimmte Hardwarekonfigurationen zurückgreift, damit Ihre Arbeitslasten immer auf Maschinen ausgeführt werden, die ihren Anforderungen entsprechen.
• Sie möchten die optimalen Konfigurationen für die gesamte Flotte Ihres Unternehmens zentral festlegen, damit Ihre Kosten vorhersehbarer sind und Ihre Arbeitslasten zuverlässiger ausgeführt werden.

Beschränkungen

Sie können keine benutzerdefinierten Compute-Klassen mit Compute Engine-Kapazitätsreservierungen im Autopilot-Modus oder in automatisch bereitgestellten Knotenpools im Standardmodus verwenden. Manuell erstellte Knotenpools im Standardmodus unterstützen Kapazitätsreservierungen.

Funktionsweise benutzerdefinierter Compute-Klassen

Benutzerdefinierte Compute-Klassen sind benutzerdefinierte Kubernetes-Ressourcen, die die Google Cloud-Infrastruktur bereitstellen. Sie definieren ein ComputeClass-Objekt im Cluster und fordern dann diese Compute-Klasse in Arbeitslasten an oder legen diese Compute-Klasse als Standard für einen Kubernetes-Namespace fest. Wenn Sie eine Arbeitslast bereitstellen, die die Compute-Klasse anfordert, versucht GKE, die Pods auf Knoten zu platzieren, die die Anforderungen der Compute-Klasse erfüllen.

Beachten Sie die folgenden Richtlinien, damit Ihre benutzerdefinierten Compute-Klassen für Ihre Flotte optimiert sind:

• Informieren Sie sich über die Rechenanforderungen Ihrer Flotte, einschließlich anwendungsspezifischer Hardwareanforderungen.
• Entscheiden Sie sich für ein Thema, das das Design jeder Compute-Klasse bestimmt. Eine leistungsoptimierte Compute-Klasse kann beispielsweise eine Fallback-Strategie haben, die nur Maschinentypen mit hoher CPU-Leistung verwendet.
• Entscheiden Sie sich für die Compute Engine-Maschinenfamilie und -Maschinenreihe, die Ihren Arbeitslasten am besten entspricht. Weitere Informationen finden Sie im Leitfaden zu Ressourcen und Vergleichen für Maschinenfamilien.
• Planen Sie für jede Compute-Klasse eine Fallback-Strategie, damit Arbeitslasten immer auf Knoten ausgeführt werden, die ähnliche Maschinenkonfigurationen verwenden. Wenn die N4-Maschinenserie beispielsweise nicht verfügbar ist, können Sie auf N2-Maschinen zurückgreifen.

Vollständige benutzerdefinierte Ressourcendefinition ansehen

Führen Sie den folgenden Befehl aus, um die vollständige benutzerdefinierte Ressourcendefinition (Custom Resource Definition, CRD) für die benutzerdefinierte Ressource ComputeClass aufzurufen:

kubectl describe crd computeclasses.cloud.google.com

Die Ausgabe zeigt die gesamte CRD, einschließlich aller unterstützten Felder und Beziehungen zwischen Feldern. Informationen zu benutzerdefinierten Compute-Klassen finden Sie in dieser Definition, während Sie dieses Dokument lesen.

Benutzerdefinierte Compute-Klasse planen

Führen Sie die folgenden Schritte aus, um eine benutzerdefinierte Compute-Klasse in Ihrem Cluster effektiv zu planen, bereitzustellen und zu verwenden:

1. Fallback-Rechenprioritäten auswählen: Hiermit legen Sie eine Reihe von Regeln fest, die die Eigenschaften der Knoten steuern, die GKE für die Compute-Klasse erstellt.
2. GKE-Standardknotenpools und Compute-Klassen konfigurieren: Führen Sie für Cluster im Standardmodus die erforderlichen Konfigurationsschritte aus, um die Compute-Klasse mit Ihren Knotenpools zu verwenden.
3. Skalierungsverhalten definieren, wenn keine Prioritätsregeln gelten: Teilen Sie GKE optional mit, was zu tun ist, wenn Knoten, die Ihren Prioritätsregeln entsprechen, nicht bereitgestellt werden können.
4. Autoscaling-Parameter für die Knotenkonsolidierung festlegen: Teilen Sie GKE mit, wann Arbeitslasten konsolidiert und nicht ausgelastete Knoten entfernt werden sollen.
5. Aktive Migration zu Knoten mit höherer Priorität konfigurieren: Sie können GKE optional anweisen, Arbeitslasten zu bevorzugten Knoten zu verschieben, sobald Hardware verfügbar ist.

Fallback-Computing-Prioritäten auswählen

Der Hauptvorteil einer benutzerdefinierten Compute-Klasse besteht darin, dass Sie die Fallback-Strategie steuern können, wenn Ihre bevorzugten Knoten aufgrund von Faktoren wie Ressourcenerschöpfung und Kontingenteinschränkungen nicht verfügbar sind.

Sie erstellen eine Fallback-Strategie, indem Sie in Ihrer benutzerdefinierten Compute-Klasse eine Liste von Prioritätsregeln definieren. Wenn ein Cluster vertikal skaliert werden muss, priorisiert GKE das Erstellen von Knoten, die der ersten Prioritätsregel entsprechen. Wenn GKE diese Knoten nicht erstellen kann, wird auf die nächste Regel mit höherer Priorität zurückgegriffen. Dieser Vorgang wird wiederholt, bis GKE den Cluster erfolgreich skaliert oder alle Regeln ausgeschöpft hat. Wenn alle Regeln ausgeschöpft sind, erstellt GKE Knoten basierend auf dem Standard- oder angegebenen Verhalten, das unter Skalierungsverhalten definieren, wenn keine Prioritätsregeln gelten beschrieben ist.

Prioritätsregeln

Prioritätsregeln werden im Feld spec.priorities der benutzerdefinierten ComputeClass-Ressource definiert. Jede Regel im Feld priorities beschreibt die Eigenschaften der zu bereitzustellenden Knoten. GKE verarbeitet das Feld priorities in der Reihenfolge. Das bedeutet, dass der erste Eintrag im Feld die höchste Priorität für die Bereitstellung von Knoten hat.

Je nach Art der Prioritätsregel können Sie zusätzliche Maschineneigenschaften wie Spot-VMs oder die minimale CPU-Kapazität angeben, die GKE bei der Bereitstellung von Knoten verwenden soll. Das Feld priorities unterstützt die folgenden Prioritätsregeltypen:

• machineFamily: Knoten werden mit einer Compute Engine-Maschinenreihe wie n2 oder c3 definiert.
• machineType: Definiert Knoten mit einem vordefinierten Compute Engine-Maschinentyp wie n2-standard-4.
• nodepools: In GKE-Standardclustern enthält diese Option eine Liste der manuell erstellten Knotenpools, die mit der Compute-Klasse verknüpft sind, in der GKE Knoten bereitstellen soll.

Regeltyp „machineFamily“

Das Feld machineFamily akzeptiert eine Compute Engine-Maschinenserie wie n2 oder c3. Wenn nicht angegeben, ist der Standardwert e2. Sie können die folgenden Felder neben dem Regeltyp machineFamily verwenden:

• spot: Spot-VMs Der Standardwert ist false.
• minCores: Mindestanzahl der vCPUs pro Knoten. Der Standardwert ist 0.
• minMemoryGb: Mindestspeicherplatz pro Knoten. Der Standardwert ist 0.
• storage.bootDiskKMSKey: Pfad zum Cloud Key Management Service-Schlüssel, der für die Verschlüsselung des Bootlaufwerks verwendet werden soll.

Das folgende Beispiel zeigt die Prioritätsregel machineFamily:

priorities:
- machineFamily: n2
  spot: true
  minCores: 16
  minMemoryGb: 64
  storage:
    bootDiskKMSKey: projects/example/locations/us-central1/keyRings/example/cryptoKeys/key-1

MachineType-Regeltyp

Das Feld machineType akzeptiert einen vordefinierten Compute Engine-Maschinentyp wie n2-standard-32. Der Maschinentyp muss alle von Ihnen angegebenen GPUs unterstützen.

Sie können die folgenden Felder neben dem Regeltyp machineType verwenden:

• spot: Spot-VMs verwenden Der Standardwert ist false.
• storage: Knotenspeicher konfigurieren.
  • storage.bootDiskType: Bootlaufwerktyp
  • storage.bootDiskKMSKey: Pfad zum Cloud KMS-Schlüssel, der für die Verschlüsselung des Bootlaufwerks verwendet werden soll.
  • storage.bootDiskSize: Größe in GB für das Bootlaufwerk des Knotens.
  • storage.localSSDCount: Anzahl der lokalen SSDs, die dem Knoten hinzugefügt werden sollen. Wenn angegeben, muss dieser mindestens 1 sein.
• gpu: GPUs konfigurieren.
  • gpu.type: Ein GPU-Typ, z. B. nvidia-l4. Weitere Informationen finden Sie unter GPU-Arbeitslasten in Autopilot bereitstellen.
  • gpu.count: Die Anzahl der anzuhängenden GPUs. Unterstützte Mengen nach GPU-Typ finden Sie unter Unterstützte GPU-Mengen.

Das folgende Beispiel zeigt eine machineType-Regel für n2-standard-32-Maschinentypen:

priorities:
- machineType: n2-standard-32
  spot: true
  storage:
    bootDiskType: pd-balanced
    bootDiskSize: 250
    localSSDCount: 2
    bootDiskKMSKey: projects/example/locations/us-central1/keyRings/example/cryptoKeys/key-1

Das folgende Beispiel zeigt eine machineType-Regel für GPUs:

priorities:
- machineType: g2-standard-16
  spot: false
  gpu:
    type: nvidia-l4
    count: 1

Regeltyp „nodepools“

Das Feld nodepools verwendet eine Liste der vorhandenen Knotenpools, in denen GKE versucht, ausstehende Pods zu erstellen. In GKE werden die Werte in diesem Feld nicht der Reihe nach verarbeitet. Sie können neben diesem Feld keine anderen Maschineneigenschaften im selben Prioritätsregelelement angeben. Dieses Feld wird nur im GKE Standard-Modus unterstützt. Weitere Informationen zur Nutzung finden Sie unter Targeting auf bestimmte Knotenpools in einer Compute-Klassendefinition.

So erstellt GKE Knoten mithilfe von Prioritätsregeln

Wenn Sie eine Arbeitslast bereitstellen, für die eine Compute-Klasse angefordert wird und ein neuer Knoten erforderlich ist, verarbeitet GKE die Liste der Regeln im Feld priorities der ComputeClass-Spezifikation der Reihe nach.

Betrachten Sie beispielsweise die folgende Spezifikation:

spec:
  ...
  priorities:
  - machineFamily: n2
    spot: true
    minCores: 64
  - machineFamily: n2
    spot: true
  - machineFamily: n2
    spot: false

Wenn Sie eine Arbeitslast bereitstellen, die eine Compute-Klasse mit diesen Prioritätsregeln anfordert, ordnet GKE die Knoten so zu:

1. GKE platziert Pods auf allen vorhandenen Knoten, die mit dieser Compute-Klasse verknüpft sind.
2. Wenn die vorhandenen Knoten die Pods nicht aufnehmen können, stellt GKE neue Knoten bereit, die die N2-Maschinenreihe verwenden, Spot-VMs sind und mindestens 64 vCPU haben.
3. Wenn N2-Spot-VMs mit mindestens 64 vCPUs in der Region nicht verfügbar sind, stellt GKE neue Knoten bereit, die N2-Spot-VMs verwenden, die in die Pods passen, unabhängig von der Anzahl der Kerne.
4. Wenn in der Region keine N2-Spot-VMs verfügbar sind, stellt GKE neue On-Demand-N2-VMs bereit.
5. Wenn keine der oben genannten Regeln erfüllt werden kann, folgt GKE der Logik im Abschnitt Skalierungsverhalten definieren, wenn keine Prioritätsregeln gelten.

GKE Standard-Knotenpools und Compute-Klassen

Wenn Sie den GKE-Standardmodus verwenden, müssen Sie möglicherweise eine manuelle Konfiguration ausführen, damit die Pods Ihrer Compute-Klasse wie erwartet geplant 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.

Manuell erstellte Knotenpools für die Verwendung mit einer Compute-Klasse konfigurieren

Wenn Ihre GKE-Standardcluster Knotenpools enthalten, die Sie manuell ohne automatische Knotenbereitstellung erstellt haben, müssen Sie diese Knotenpools konfigurieren, um sie bestimmten Compute-Klassen zuzuordnen. GKE plant Pods, die eine bestimmte Compute-Klasse anfordern, nur auf Knoten in Knotenpools, die Sie dieser Compute-Klasse zuordnen. Knotenpools im GKE Autopilot-Modus und im GKE-Standardmodus, die durch die automatische Knotenbereitstellung erstellt wurden, führen diese Konfiguration automatisch aus.

Wenn Sie einen manuell erstellten Knotenpool mit einer Compute-Klasse verknüpfen möchten, fügen Sie dem Knotenpool beim Erstellen oder Aktualisieren Knotenlabels und Knotenmarkierungen hinzu. Geben Sie dazu das Flag --node-labels und das Flag --node-taints an:

• Knotenlabel: cloud.google.com/compute-class=COMPUTE_CLASS
• Markierung: cloud.google.com/compute-class=COMPUTE_CLASS:NoSchedule

In diesen Attributen ist COMPUTE_CLASS der Name Ihrer benutzerdefinierten Compute-Klasse.

Mit dem folgenden Befehl wird beispielsweise ein vorhandener Knotenpool aktualisiert und der Compute-Klasse dev-class zugeordnet:

gcloud container node-pools update dev-pool \
    --cluster=example-cluster \
    --node-labels="cloud.google.com/compute-class=dev-class" \
    --node-taints="cloud.google.com/compute-class=dev-class:NoSchedule"

Sie können jedem Knotenpool in Ihrem Cluster eine benutzerdefinierte Compute-Klasse zuweisen. Pods, die GKE auf diesen manuell erstellten Knotenpools plant, lösen nur während Autoscaling-Ereignissen die Knotenerstellung in diesen Knotenpools aus.

Automatische Bereitstellung von Knoten und Compute-Klassen

Sie können die automatische Knotenbereitstellung mit einer benutzerdefinierten Compute-Klasse verwenden, damit GKE Knotenpools automatisch basierend auf Ihren Prioritätsregeln erstellen und löschen kann.

So verwenden Sie die automatische Knotenbereitstellung mit einer Compute-Klasse:

1. Die automatische Knotenbereitstellung muss in Ihrem Cluster aktiviert sein.
2. Fügen Sie der Spezifikation ComputeClass das Feld nodePoolAutoCreation mit dem Wert enabled: true hinzu.

GKE kann dann Pods platzieren, die Compute-Klassen verwenden, die die automatische Knotenbereitstellung in neuen Knotenpools konfigurieren. GKE entscheidet basierend auf Faktoren wie der Größe der Cluster und den Pod-Anforderungen, ob ein vorhandener Knotenpool hochskaliert oder ein neuer Knotenpool erstellt wird. Bei Pods mit Compute-Klassen, für die die automatische Knotenbereitstellung nicht konfiguriert ist, werden weiterhin nur vorhandene Knotenpools skaliert.

Sie können Compute-Klassen, die mit der automatischen Knotenbereitstellung interagieren, zusammen mit Compute-Klassen verwenden, die mit manuell erstellten Knotenpools im selben Cluster interagieren.

Berücksichtigen Sie die folgenden Interaktionen mit der automatischen Knotenbereitstellung:

• Sie können die Knotenauswahlen Machinenfamilie und Spot-VMs nicht verwenden, da diese Auswahlen mit dem Verhalten der Compute-Klasse in Konflikt stehen. GKE lehnt alle Pods ab, die eine Compute-Klasse und auch Spot-VMs oder bestimmte Maschinenreihen anfordern.
• Sie können die automatische Knotenbereitstellung für Compute-Klassen konfigurieren, die das Feld nodepools verwenden, um auf vorhandene Knotenpools zu verweisen. Bei der automatischen Knotenbereitstellung werden die Prioritäten der Reihe nach verarbeitet und versucht, die vorhandenen Knotenpools zu skalieren, um Ihre Pods zu platzieren.

Betrachten Sie das folgende Beispiel für einen Cluster, der sowohl manuell erstellte Knotenpools als auch automatische Knotenbereitstellung enthält:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: my-class
spec:
  priorities:
  - nodepools: [manually-created-pool]
  - machineFamily: n2
  - machineFamily: n2d
  nodePoolAutoCreation:
    enabled: true

In diesem Beispiel versucht GKE Folgendes:

1. Erstellen Sie neue Knoten im Knotenpool manually-created-pool.
2. N2-Knoten entweder in vorhandenen N2-Knotenpools bereitstellen oder einen neuen Knotenpool erstellen
3. Wenn GKE keine N2-Knoten erstellen kann, wird versucht, vorhandene N2D-Knotenpools vertikal zu skalieren oder neue N2D-Knotenpools zu erstellen.

In einer Compute-Klassendefinition bestimmte Knotenpools als Ziel festlegen

Im Feld priorities.nodepools können Sie eine Liste von manuell erstellten Knotenpools angeben, in denen GKE in GKE-Standardclustern, die Cluster-Autoscaling verwenden, versucht, Pods in keiner bestimmten Reihenfolge zu planen. Dieses Feld unterstützt nur eine Liste von Knotenpools. Sie können in derselben Prioritätsregel keine zusätzlichen Maschineneigenschaften wie die Maschinenreihe angeben. Wenn Sie eine Arbeitslast bereitstellen, die eine Compute-Klasse mit benannten Knotenpools anfordert, versucht GKE, die ausstehenden Pods in diesen Knotenpools zu planen. GKE kann in diesen Knotenpools neue Knoten erstellen, um die Pods zu platzieren.

Die Knotenpools, die Sie im priorities.nodepools-Feld angegeben haben,müssen dieser Compute-Klasse mithilfe von Knotenlabels und Knotenmarkierungen zugeordnet werden, wie in den Manuell erstellte Knotenpools für Compute-Klassen konfigurieren angegeben.

Die Liste der Knotenpools, die Sie im Feld nodepools angeben, hat keine Priorität. Zum Konfigurieren einer Fallback-Reihenfolge für benannte Knotenpools müssen Sie mehrere separate priorities.nodepools-Elemente angeben. Betrachten Sie beispielsweise die folgende Spezifikation:

spec:
  ...
  priorities:
  - nodepools: [pool1, pool2]
  - nodepools: [pool3]

In diesem Beispiel versucht GKE zuerst, ausstehende Pods, die diese Compute-Klasse anfordern, auf vorhandenen Knoten in Knotenpools zu platzieren, die mit der Compute-Klasse gekennzeichnet sind. Wenn vorhandene Knoten nicht verfügbar sind, versucht GKE, neue Knoten in pool1 oder pool2 bereitzustellen. Wenn GKE keine neuen Knoten in diesen Knotenpools bereitstellen kann, versucht GKE, neue Pods in pool3 bereitzustellen.

Skalierungsverhalten definieren, wenn keine Prioritätsregeln gelten

Mit der benutzerdefinierten Ressource ComputeClass können Sie angeben, was GKE tun soll, wenn keine Knoten vorhanden sind, die eine der Prioritätsregeln erfüllen können. Das Feld whenUnsatisfiable in der Spezifikation unterstützt die folgenden Werte:

• ScaleUpAnyway: Einen neuen Knoten erstellen, der die Standardmaschinenkonfiguration des Clusters verwendet Das ist das Standardverhalten.
  • In Autopilot-Clustern platziert GKE den Pod unabhängig von der Konfiguration der Knotenmaschine auf einem neuen oder vorhandenen Knoten.
  • In Standardclustern, die keine automatische Knotenbereitstellung verwenden, versucht GKE, jeden manuell erstellten Knotenpool hochzuskalieren, der ein Label und eine Markierung definiert, die einer bestimmten Compute-Klasse entsprechen.
  • In Standardclustern, in denen die automatische Knotenbereitstellung verwendet wird, erstellt GKE möglicherweise einen neuen Knotenpool, in dem der Pod mit der Standard-E2-Maschinenreihe platziert wird.
• DoNotScaleUp: Belassen Sie den Pod im Status Pending, bis ein Knoten verfügbar ist, der die Anforderungen der Compute-Klasse erfüllt.

Autoscaling-Parameter für die Knotenkonsolidierung festlegen

Standardmäßig entfernt GKE nicht ausgelastete Knoten durch das Ausführen von Arbeitslasten. Dadurch werden diese Arbeitslasten auf anderen Knoten mit Kapazität konsolidiert. Dies ist für alle Compute-Klassen das Standardverhalten, da alle Cluster, die Compute-Klassen verwenden, den Cluster Autoscaler verwenden oder Autopilot-Cluster sind. Bei einer Knotenkonsolidierung entlastet GKE einen nicht optimal genutzten Knoten, erstellt die Arbeitslasten auf einem anderen Knoten neu und löscht den entlasteten Knoten.

Der Zeitpunkt und die Kriterien für das Entfernen des Knotens hängen vom Autoscaling-Profil ab. Sie können die Grenzwerte für die Unterauslastung von Ressourcen, die das Entfernen von Knoten und die Konsolidierung von Arbeitslasten auslösen, im Abschnitt autoscalingPolicy in der Definition Ihrer benutzerdefinierten Compute-Klasse optimieren. Sie können die folgenden Parameter optimieren:

• consolidationDelayMinutes: Die Anzahl der Minuten, nach denen GKE nicht ausreichend genutzte Knoten entfernt
• consolidationThreshold: Der Auslastungsgrenzwert für CPU und Arbeitsspeicher als Prozentsatz der verfügbaren Ressourcen des Knotens. GKE berücksichtigt nur dann Knoten zum Entfernen, wenn die Ressourcennutzung unter diesem Schwellenwert liegt.
• gpuConsolidationThreshold: Der Auslastungsgrenzwert für die GPU als Prozentsatz der verfügbaren Ressourcen des Knotens. GKE berücksichtigt nur dann Knoten zum Entfernen, wenn die Ressourcennutzung unter diesem Schwellenwert liegt. Legen Sie diesen Wert auf 100 oder 0 fest, damit GKE alle Knoten konsolidiert, bei denen die angeschlossenen GPUs nicht zu 100 % ausgelastet sind.

Dazu ein Beispiel:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: my-class
spec:
  priorities:
  - machineFamily: n2
  - machineFamily: n2d
  autoscalingPolicy:
    consolidationDelayMinutes: 5
    consolidationThreshold: 70

In dieser Konfiguration entfernt GKE nicht verwendete Knoten nach fünf Minuten. Knoten werden nur dann für die Konsolidierung ausgewählt, wenn sowohl ihre CPU- als auch ihre Arbeitsspeicherauslastung unter 70 % liegt.

Aktive Migration zu Knoten mit höherer Priorität konfigurieren

Die aktive Migration ist eine optionale Autoscaling-Funktion in benutzerdefinierten Compute-Klassen, die vorhandene Knoten, die in einer Fallback-Prioritätsliste für Compute-Klassen niedriger sind, automatisch durch neue Knoten ersetzt, die in dieser Prioritätsliste weiter oben sind. So werden alle laufenden Pods schließlich auf den für diese Compute-Klasse am besten geeigneten Knoten ausgeführt, auch wenn GKE diese Pods ursprünglich auf weniger geeigneten Knoten ausführen musste.

Bei einer aktiven Migration erstellt GKE neue Knoten basierend auf den Prioritätsregeln der Compute-Klasse und drosselt und löscht dann die veralteten Knoten mit niedrigerer Priorität. Die Migration erfolgt schrittweise, um die Unterbrechung der Arbeitslast zu minimieren. Bei aktiven Migrationen ist Folgendes zu beachten:

• Wenn Sie die automatische Knotenbereitstellung in Ihren Standardclustern aktiviert haben, kann eine aktive Migration das Erstellen neuer Knotenpools auslösen, wenn vorhandene Knotenpools die Kriterien mit höherer Priorität nicht erfüllen, die in Ihrer benutzerdefinierten Compute-Klasse definiert sind.
• Um Unterbrechungen kritischer Arbeitslasten zu vermeiden, werden bei der aktiven Migration die folgenden Pods nicht verschoben:
  • Pods, für die ein PodDisruptionBudget festgelegt ist, wenn die Migration das PodDisruptionBudget überschreiten würde.
  • Pods mit der Anmerkung cluster-autoscaler.kubernetes.io/safe-to-evict: "false"

In der folgenden Beispielspezifikation für die Compute-Klasse werden N2-Knoten N2D-Knoten vorgezogen:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: my-class
spec:
  priorities:
  - machineFamily: n2
  - machineFamily: n2d
  activeMigration:
    optimizeRulePriority: true

Wenn bei der Bereitstellung eines Pods mit dieser Compute-Klasse keine N2-Knoten verfügbar wären, hätte GKE N2D-Knoten als Fallback-Option verwendet. Wenn N2-Knoten für die spätere Bereitstellung verfügbar sind, z. B. wenn Ihr Kontingent erhöht wird oder wenn N2-VMs an Ihrem Standort verfügbar sind, erstellt GKE einen neuen N2-Knoten und migriert den Pod schrittweise vom vorhandenen N2D-Knoten zu den neuen N2-Knoten. GKE löscht dann den veralteten N2D-Knoten.

Compute-Klassen in Arbeitslasten anfordern

Wenn Sie eine benutzerdefinierte Compute-Klasse nach dem Entwerfen verwenden möchten, muss Ihr Pod diese Compute-Klasse in der Pod-Spezifikation explizit anfordern. Sie können optional eine Compute-Klasse in einem bestimmten Kubernetes-Namespace als Standard festlegen. In diesem Fall wird diese Compute-Klasse von Pods in diesem Namespace verwendet, sofern die Pods keine andere Compute-Klasse anfordern.

Eine Anleitung zum Anfordern und Verwenden von Compute-Klassen in GKE finden Sie unter Autoscaled Node Attributes with Custom Compute Classes (Autoscaled Node Attributes with Custom Compute Classes).

Nächste Schritte

• Weitere Empfehlungen zur Arbeitslastbereitstellung in GKE Autopilot