Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Granulare Ressourcenlimits konfigurieren

Autopilot Standard

Um die Verwaltung von Infrastrukturkosten und Kontingenten zu optimieren, können Sie maximale Ressourcenlimits für die automatische Skalierung von Google Kubernetes Engine-Clustern (GKE) definieren. In diesem Dokument wird beschrieben, wie Sie mit der benutzerdefinierten Ressource „CapacityQuota“ Autoscaling-Ressourcenlimits für Teilmengen von Knoten festlegen. Im Gegensatz zu clusterweiten Ressourcenlimits können Sie mit Kubernetes-Labelselektoren bestimmte Knoten in einem CapacityQuota auswählen.

Dieses Dokument richtet sich an Plattformadministratoren, die die Clusterskalierung und Infrastruktur verwalten. Sie sollten mit Kubernetes-Knotenlabels und dem Cluster-Autoscaler von GKE vertraut sein.

So funktionieren Ressourcenlimits für CapacityQuota

Ein CapacityQuota ist eine benutzerdefinierte Kubernetes-Ressource auf Clusterebene, die Sie in einem Manifest konfigurieren und auf den Cluster anwenden. Mit den folgenden Feldern in der CapacityQuota-Spezifikation können Sie Knoten auswählen und Ressourcenlimits angeben:

selector: Mit einem oder mehreren Labelselektoren können Sie nach bestimmten Knoten filtern. Sie können beispielsweise alle Knoten für eine bestimmte Compute-Klasse oder Knoten mit zwei bestimmten Labels auswählen.
limits: Geben Sie maximale Ressourcenlimits für die Knoten an, die den Selektoren entsprechen. Sie können beispielsweise die Menge an CPU-Ressourcen begrenzen, die von einer bestimmten benutzerdefinierten ComputeClass verwendet werden kann, oder die Anzahl der GPUs eines bestimmten Typs begrenzen.

Wenn ein Hochskalierungsvorgang beginnt, prüft das Cluster-Autoscaling den vorgeschlagenen Knoten anhand aller CapacityQuotas, die mit den Knotenlabels übereinstimmen, und anhand aller konfigurierten clusterweiten Ressourcenlimits. GKE erstellt den Knoten nur, wenn er nicht gegen konfigurierte Ressourcenlimits verstößt.

Beschränkungen

GKE lehnt CapacityQuotas ab, die die Labelselektoren node.kubernetes.io/instance-type und beta.kubernetes.io/instance-type angeben. Wenn Sie Knoten mit einem bestimmten Maschinentyp einschränken möchten, erstellen Sie eine benutzerdefinierte ComputeClass mit machineType-Prioritätsregeln und wählen Sie diese ComputeClass in Ihrem CapacityQuota aus.
Ähnlich wie bei clusterweiten Limits können CapacityQuotas die aktive Migration von ComputeClass verhindern. Da die aktive Migration ein Scale-up-Vorgang ist, prüft der Cluster Autoscaler den potenziellen neuen Knoten anhand aller anwendbaren CapacityQuotas und clusterweiten Ressourcenlimits. Wenn der neue Knoten gegen eines dieser Limits verstößt, erstellt GKE den Knoten nicht und die aktive Migration wird nicht ausgeführt. Dies geschieht nur, wenn das CapacityQuota bereits die konfigurierten Grenzwerte erreicht oder fast erreicht hat.
CapacityQuota-Limits sind keine strikten Limits. In seltenen Fällen kann es vorkommen, dass GKE die konfigurierten Grenzwerte geringfügig überschreitet.
CapacityQuota-Limits werden nur vom Cluster-Autoscaler erzwungen. Sie können die Limits überschreiten, indem Sie den Cluster manuell hochskalieren oder die Limits so ändern, dass sie unter der aktuellen Nutzung liegen.
Wenn Knoten im Cluster die konfigurierten CapacityQuota-Grenzwerte überschreiten, blockiert der Cluster Autoscaler die Erstellung neuer Knoten, die dem überschrittenen CapacityQuota entsprechen. Der Cluster-Autoscaler skaliert keine vorhandenen Knoten herunter, die dem CapacityQuota entsprechen.

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. In früheren gcloud CLI-Versionen werden die Befehle in diesem Dokument möglicherweise nicht unterstützt.
Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI das compute/region-Attribut fest. Wenn Sie hauptsächlich zonale Cluster verwenden, legen Sie stattdessen compute/zone fest. Wenn Sie einen standardmäßigen Speicherort festlegen, können Sie in der gcloud CLI Fehler wie diesen vermeiden: One of [--zone, --region] must be supplied: Please specify location. Bei bestimmten Befehlen müssen Sie möglicherweise den Speicherort angeben, wenn er sich von dem von Ihnen festgelegten Standard unterscheidet.

Sie benötigen einen Autopilot- oder Standardcluster mit Version 1.36.2-gke.2064000 oder höher. Informationen zum Erstellen eines neuen Clusters finden Sie unter Autopilot-Cluster erstellen.

Ressourcenlimits in einem CapacityQuota konfigurieren

Sie können die Knoten, für die ein CapacityQuota gilt, mit einer oder beiden der folgenden Methoden auswählen:

Knoten anhand genauer Knotenlabels auswählen: Geben Sie im Feld matchLabels ein oder mehrere Schlüssel/Wert-Paare für Knotenlabels an. GKE sucht nach Knoten, die alle von Ihnen angegebenen Labels haben. Diese Methode ähnelt der Verwendung des Felds nodeSelector in einer Pod-Spezifikation.
Knoten mithilfe von Ausdrücken auswählen: Geben Sie einen oder mehrere Labelselektorausdrücke an, indem Sie den Labelschlüssel, Operatoren und Werte angeben. Diese Methode ähnelt der Verwendung des Felds nodeAffinity in einer Pod-Spezifikation.

Knoten mithilfe von Knotenlabels auswählen

So erstellen Sie ein CapacityQuota basierend auf dem Abgleich von Knotenlabels mit dem Feld matchLabels:

Speichern Sie eines der folgenden CapacityQuotas-Beispiele, die jeweils für einen bestimmten Anwendungsfall vorgesehen sind:
- Sie können Ressourcenlimits für eine gesamte benutzerdefinierte ComputeClass konfigurieren, indem Sie das Label cloud.google.com/compute-class angeben:
```
apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityQuota
metadata:
  name: capacity-quota-compute-class
spec:
  selector:
    matchLabels:
      cloud.google.com/compute-class: my-class
  limits:
    resources:
      cpu: 12
```
  Dieses CapacityQuota beschränkt den Cluster Autoscaler auf maximal 12 CPUs für alle Knoten, die GKE für die Compute-Klasse my-class erstellt.
- Sie können Limits für die Anzahl der GPUs eines bestimmten Typs konfigurieren, indem Sie das Label cloud.google.com/gke-accelerator und den Ressourcennamen nvidia.com/gpu verwenden:
```
apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityQuota
metadata:
  name: capacity-quota-gpu
spec:
  selector:
    matchLabels:
      cloud.google.com/compute-class: my-gpu-class
      cloud.google.com/gke-accelerator: nvidia-tesla-t4
  limits:
    resources:
      nvidia.com/gpu: 16
```
  Dieses CapacityQuota beschränkt den Cluster Autoscaler auf maximal 16 NVIDIA Tesla T4-GPUs in der ComputeClass my-gpu-class. Wenn Sie die ComputeClass-Auswahl weglassen, gilt das Limit für alle NVIDIA Tesla T4-GPU-Knoten im Cluster.
- Konfigurieren Sie mit dem Label topology.kubernetes.io/zone und dem Ressourcennamen nodes Grenzwerte für die Anzahl der Knoten, die GKE in einer bestimmten Zone erstellt:
```
apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityQuota
metadata:
  name: capacity-quota-zone
spec:
  selector:
    matchLabels:
      topology.kubernetes.io/zone: us-central1-b
  limits:
    resources:
      nodes: 64
```
  Dieses CapacityQuota beschränkt den Cluster Autoscaler auf 64 Knoten in der Zone us-central1-b.
Erstellen Sie das CapacityQuota:
```
kubectl apply -f PATH_TO_MANIFEST_FILE
```
Ersetzen Sie PATH_TO_MANIFEST_FILE durch den Pfad zur von Ihnen erstellten CapacityQuota-Manifestdatei.

Knoten mithilfe von Ausdrücken auswählen

Für komplexere Ausrichtung unterstützt CapacityQuota die Definition des Felds matchExpressions zusätzlich zum Feld matchLabels. Der matchExpressions-Operator ermöglicht Operatoren wie In, NotIn, Exists und DoesNotExist.

Erstellen Sie ein CapacityQuota-Manifest, in dem das Feld matchExpressions verwendet wird. Im folgenden Beispiel für ein CapacityQuota werden CPU- und Arbeitsspeicherlimits auf Knoten angewendet, die auf bestimmten Hochleistungs-Maschinenfamilien ausgeführt werden. Dazu werden sie mit dem Operator In gruppiert:

apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityQuota
metadata:
  name: capacity-quota-high-perf-machines
spec:
  selector:
    matchExpressions:
      - key: cloud.google.com/machine-family
        operator: In
        values:
          - c2
          - c3
          - c3d
  limits:
    resources:
      cpu: 64
      memory: 128Gi

Wenden Sie das Manifest auf Ihren Cluster an:
```
kubectl apply -f PATH_TO_MANIFEST_FILE
```
Ersetzen Sie PATH_TO_MANIFEST_FILE durch den Pfad zur CapacityQuota-Manifestdatei, die Sie erstellt haben.

CapacityQuota-Konfiguration prüfen

In diesem Abschnitt erfahren Sie, wie Sie prüfen, ob ein CapacityQuota-Objekt Limits aktiv erzwingt. Dazu stellen Sie eine Beispielarbeitslast bereit, die gegen diese Limits verstößt. So führen Sie diese Überprüfung durch:

Speichern Sie die folgende Beispiel-ComputeClass als test-capacityquota-class.yaml:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: test-capacityquota-class
spec:
  priorities:
  - machineFamily: n2
  nodePoolAutoCreation:
    enabled: true

Diese ComputeClass kann automatisch Knoten erstellen, die die N2-Maschinenserie verwenden.

ComputeClass erstellen:

kubectl apply -f test-capacityquota-class.yaml

Speichern Sie das folgende Beispiel für CapacityQuota als test-capacityquota.yaml:

apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityQuota
metadata:
  name: test-capacityquota
spec:
  selector:
    matchLabels:
      cloud.google.com/compute-class: test-capacityquota-class
  limits:
    resources:
      cpu: 8

Dieses CapacityQuota beschränkt den Autoscaler auf maximal 8 CPU-Ressourcen für die ComputeClass test-capacityquota-class.

Erstellen Sie das CapacityQuota:

kubectl apply -f test-capacityquota.yaml

Speichern Sie das folgende Deployment als test-capacityquota-workload.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-capacityquota-workload
spec:
  replicas: 16
  selector:
    matchLabels:
      app: test-capacityquota-workload
  template:
    metadata:
      labels:
        app: test-capacityquota-workload
    spec:
      containers:
      - name: test
        image: gcr.io/google_containers/pause
        resources:
          limits:
            cpu: 500m
      nodeSelector:
        cloud.google.com/compute-class: test-capacityquota-class

Dieses Deployment erstellt 16 Pods, die jeweils 500 mCPU anfordern. Da Knoten einige CPUs für Systemkomponenten reservieren, ist die Summe der CPU-Ressourcen für alle Knoten, die GKE zum Ausführen der 16 Pods erstellen muss, größer als 8.

Erstellen Sie das Deployment:

kubectl apply -f test-capacityquota-workload.yaml

Warten Sie etwa zwei Minuten und prüfen Sie dann den Status der Pod-Planung:
```
kubectl get pods -l app=test-capacityquota-workload
```
Der Cluster Autoscaler skaliert Knoten auf das CapacityQuota-Limit von 8 CPUs. Nach Erreichen dieses Limits erstellt der Autoscaler keine Knoten mehr. Daher verbleiben einige Pods im Deployment im Status Pending.

So prüfen Sie, ob das CapacityQuota den Status Pending verursacht hat: Beschreiben Sie einen der ausstehenden Pods:

kubectl describe pod PENDING_POD_NAME

Ersetzen Sie PENDING_POD_NAME durch den Namen eines Pods, der im Status Pending hängen geblieben ist.

Die Ausgabe sieht etwa so aus, was darauf hinweist, dass das Hochskalieren von Knoten durch das CapacityQuota blockiert wurde:

Pod didn't trigger scale-up: 1 exceeded quota: "CapacityQuota/test-capacityquota", resources: cpu

Sie können diese Ereignisse auch mit den Sichtbarkeitslogs für Cluster Autoscaler ansehen. Prüfen Sie das noScaleUp-Ereignis, wie im folgenden Beispiel:

{
  "jsonPayload": {
    "noDecisionStatus": {
      "noScaleUp": {
        "skippedMigs": [
          {
            "reason": {
              "parameters": [
                "exceeded quota: \"CapacityQuota/test-capacityquota\", resources: cpu"
              ],
              "messageId": "no.scale.up.mig.skipped"
            },
            "mig": {
              "name": "gke-test-grp",
              "zone": "us-central1-f",
              "nodepool": "nap-n2-highcpu-2-test"
            }
          }
        ]
      }
    }
  }
}

Nutzung und Gültigkeit von CapacityQuotas prüfen

Das Feld status in der CapacityQuota API-Ressource enthält Informationen zur Ressourcennutzung für Knoten, die dem CapacityQuota entsprechen, sowie zur Gültigkeit der CapacityQuota-Spezifikation.

Führen Sie den folgenden Befehl aus, um den Status eines CapacityQuota zu prüfen:

kubectl describe capacityquota CAPACITY_QUOTA_NAME

Ersetzen Sie CAPACITY_QUOTA_NAME durch den Namen des CapacityQuota, den Sie prüfen möchten.

Prüfen Sie in der Ausgabe die folgenden Felder:

Verwenden Sie das Feld status.used, um die Ressourcennutzung der übereinstimmenden Knoten zu prüfen:
```
status:
  conditions:
  - lastTransitionTime: "2026-07-27T10:00:00Z"
    message: "CapacityQuota is valid"
    reason: "Valid"
    status: "True"
    type: "cluster-autoscaler.kubernetes.io/valid"
  used:
    resources:
      cpu: 32
      memory: 128Gi
```
Das Feld status.used ist für die Beobachtbarkeit vorgesehen und wird vom Cluster-Autoscaler nicht zum Erzwingen von Limits verwendet. In diesem Feld wird die Nutzung erst nach einem erfolgreichen Hochskalierungsvorgang angezeigt. Der Cluster-Autoscaler verfolgt auch ausstehende Knoten intern und berücksichtigt diese ausstehenden Knoten bei nachfolgenden Hochskalierungsbewertungen. Dieses interne Tracking hilft, das Überschreiten von Limits zu verhindern.
Verwenden Sie das Feld status.conditions, um die Gültigkeit eines CapacityQuota zu prüfen:
```
status:
  conditions:
  - lastTransitionTime: "2026-07-27T10:00:00Z"
    message: "CapacityQuota is valid"
    reason: "Valid"
    status: "True"
    type: "cluster-autoscaler.kubernetes.io/valid"
  used:
    resources:
      cpu: 32
      memory: 128Gi
```
Mit der Bedingung cluster-autoscaler.kubernetes.io/valid wird geprüft, ob für CapacityQuota eine gültige Konfiguration verwendet wird, z. B. ein korrekt formatierter Selektor. Wenn der Wert im Feld status für diese Bedingung True ist, ist das CapacityQuota gültig und Ihre Limits werden erzwungen. Wenn der Wert im Feld status jedoch False ist oder die Bedingung noch nicht vorhanden ist, werden die Limits nicht erzwungen. Das Feld message enthält Details dazu, warum das CapacityQuota ungültig ist.