Kapazitätsreserven konfigurieren

Kapazitätspuffer verbessern die Reaktionsfähigkeit und Zuverlässigkeit kritischer Arbeitslasten, indem sie die freie Clusterkapazität proaktiv mithilfe einer benutzerdefinierten Kubernetes-Ressourcendefinition (CustomResourceDefinition, CRD) vom Typ `CapacityBuffer` verwalten. Mit einem Kapazitätspuffer können Sie explizit eine bestimmte Menge an ungenutzter Knotenskapazität in Ihrem Cluster definieren. Diese reservierte Kapazität trägt dazu bei, dass GKE Knoten im Voraus bereitstellt.

Wenn eine Arbeitslast mit hoher Priorität schnell skaliert werden muss, kann die neue Arbeitslast die freie Kapazität sofort nutzen, ohne auf die Knotenbereitstellung warten zu müssen. Dadurch wird die Latenz minimiert und Ressourcenkonflikte bei plötzlichen Nachfragespitzen vermieden.

Auf dieser Seite werden drei Methoden zum Konfigurieren von Kapazitätspuffern beschrieben: ein Puffer mit fester Anzahl von Replikaten, ein prozentualer Puffer und ein Puffer mit Ressourcenlimits.

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 diesen Task 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 Versionen der gcloud CLI unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.
  • Erstellen Sie einen GKE-Cluster mit Version 1.35.2-gke.1842000 oder höher oder haben Sie Zugriff darauf.
  • (Optional, aber empfohlen) Aktivieren Sie die automatische Knotenbereitstellung in Ihrem Cluster.

Erforderliche Kubernetes-Objekte erstellen

Zum Konfigurieren eines `CapacityBuffer` benötigen Sie einen Namespace, der alle erforderlichen Objekte enthält: den `CapacityBuffer` selbst und zusätzliche Ressourcen wie eine PodTemplate oder eine Arbeitslast. Die PodTemplate und der `CapacityBuffer` müssen sich im selben Namespace befinden. Sie können einen Namespace erstellen oder einen vorhandenen Namespace verwenden, einschließlich des Namespace default.

Je nachdem, welchen Typ von `CapacityBuffer` Sie konfigurieren, benötigen Sie außerdem eines der folgenden Elemente:

  • PodTemplate: definiert die Ressourcenanforderungen für eine einzelne Einheit der Pufferkapazität. Die im `CapacityBuffer`-Objekt angegebene Konfiguration verweist auf die Pod-Vorlage.

  • Arbeitslast: eine vorhandene Arbeitslast, auf die Sie im `CapacityBuffer` -Objekt verweisen. In diesem Leitfaden wird ein Deployment-Objekt als Beispielarbeitslast verwendet. Kapazitätspuffer unterstützen jedoch alle folgenden Ressourcentypen:

    • Bereitstellung
    • ReplicaSet
    • StatefulSet
    • ReplicationController
    • Job

    • CustomResourceDefinitions (CRDs), die die Unterressource scale implementieren.

In diesem Abschnitt finden Sie Beispiele für diese Objekte. Wenn Sie bereits eine Arbeitslast haben, die Sie mit einem Kapazitätspuffer konfigurieren möchten, fahren Sie mit Kapazitätspuffer anwenden fort.

So erstellen Sie eine Beispielarbeitslast für Kubernetes:

  1. Speichern Sie das folgende Manifest als namespace.yaml:

    apiVersion: v1
kind: Namespace
metadata:
  name: capacity-buffer-example
  labels:
    name: capacity-buffer-example

    Dieses Manifest erstellt einen Namespace namens capacity-buffer-example.

  2. Speichern Sie das folgende Manifest als buffer-pod-template.yaml:

    apiVersion: v1
kind: PodTemplate
metadata:
  name: buffer-unit-template
  namespace: capacity-buffer-example # the namespace must be the same namespace as the CapacityBuffer
template:
  spec:
    terminationGracePeriodSeconds: 0
    containers:
    - name: buffer-container
      image: registry.k8s.io/pause:3.9
      resources:
        requests:
          cpu: "1"
          memory: "1Gi"
        limits:
          cpu: "1"
          memory: "1Gi"

    Dieses Manifest erstellt eine PodTemplate, die die Ressourcenanforderungen für eine einzelne Einheit der Pufferkapazität (1 CPU und 1Gi Arbeitsspeicher) definiert. Diese Konfiguration gibt die Größe der Kapazitätseinheiten an, die GKE für den Puffer bereitstellt. Mit dieser PodTemplate berücksichtigt GKE beispielsweise keine Knoten mit weniger als 1 CPU und 1 GiB verfügbarer Ressourcen als Teil des Puffers, wenn der Cluster skaliert wird.

  3. Speichern Sie das folgende Manifest als sample-workload-deployment.yaml:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: critical-workload-ref
  namespace: capacity-buffer-example # the namespace must be the same namespace as the CapacityBuffer
spec:
  replicas: 10
  selector:
    matchLabels:
      app: critical-workload
  template:
    metadata:
      labels:
        app: critical-workload
    spec:
      containers:
      - name: busybox
        image: busybox
        command: ["sleep", "3600"]
        resources:
          requests:
            cpu: 100m

    Dieses Manifest erstellt ein Beispiel-Deployment mit 10 Replikaten. Es ist das Referenzobjekt für das prozentuale Pufferbeispiel im nächsten Abschnitt.

  4. Wenden Sie die Manifeste auf Ihren Cluster an:

    kubectl apply -f namespace.yaml -f buffer-pod-template.yaml -f sample-workload-deployment.yaml

  5. Prüfen Sie, ob GKE die Objekte erstellt hat:

    kubectl get podtemplate -n capacity-buffer-example
kubectl get deployment critical-workload-ref -n capacity-buffer-example

    Die Ausgabe sieht etwa so aus:

    NAME                   AGE
buffer-unit-template   1m

NAME                    READY   UP-TO-DATE   AVAILABLE   AGE
critical-workload-ref   10/10   10           10          1m

Kapazitätspuffer anwenden

In diesem Abschnitt finden Sie Beispiele für die verschiedenen Arten von Kapazitätspuffern, die Sie auf Ihre Arbeitslasten anwenden können.

Puffer mit fester Anzahl von Replikaten konfigurieren

Wenn Sie einen `CapacityBuffer` mit einer festen Anzahl von Replikaten konfigurieren, geben Sie die genaue Anzahl der gewünschten Puffereinheiten basierend auf einer PodTemplate an.

So erstellen Sie einen Puffer mit einer festen Anzahl von Replikaten:

  1. Speichern Sie das folgende Manifest als cb-fixed-replicas.yaml:

    apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityBuffer
metadata:
  name: fixed-replica-buffer
  namespace: NAMESPACE
spec:
  podTemplateRef:
    name: POD_TEMPLATE
  replicas: 3

    Ersetzen Sie Folgendes:

    • NAMESPACE: Der Name Ihres Namespace, z. B. capacity-buffer-example.
    • POD_TEMPLATE: Die PodTemplate, die Ihre Ressourcenanforderungen definiert, z. B. buffer-unit-template.

    Dieses Manifest erstellt eine `CapacityBuffer`-Ressource, die auf eine PodTemplate verweist, um eine bestimmte Anzahl von Puffereinheiten anzufordern.

  2. Wenden Sie das Manifest an:

    kubectl apply -f cb-fixed-replicas.yaml

  3. Prüfen Sie, ob GKE den Kapazitätspuffer angewendet hat:

    kubectl get capacitybuffer fixed-replica-buffer -n NAMESPACE

    Im Feld replicas des Status sollte 3 angezeigt werden. Das entspricht der Anzahl der Replikate, die Sie im Manifest definiert haben. Im Feld STATUS sollte ReadyForProvisioning angezeigt werden.

Prozentualen Puffer konfigurieren

Wenn Sie einen prozentualen Puffer konfigurieren, wird die Größe des Puffers dynamisch basierend auf einem Prozentsatz einer vorhandenen skalierbaren Arbeitslast festgelegt.

So erstellen Sie einen prozentualen Puffer:

  1. Speichern Sie das folgende Manifest als cb-percentage-based.yaml:

    apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityBuffer
metadata:
  name: percentage-buffer
  namespace: NAMESPACE
spec:
  scalableRef:
    apiGroup: apps
    kind: Deployment
    name: SCALABLE_RESOURCE_NAME
  percentage: 20

    Ersetzen Sie Folgendes:

    • NAMESPACE: Der Name Ihres Namespace.
    • SCALABLE_RESOURCE_NAME: Der Name Ihrer skalierbaren Ressource, z. B. critical-workload-ref.

    Dieses Manifest erstellt eine `CapacityBuffer`-Ressource, die eine Puffergröße anfordert, die 20% der Replikate der referenzierten Ressource entspricht. Wenn Sie das Deployment-Beispiel aus dem vorherigen Abschnitt verwenden, ist der Wert für die Replikate auf 10 festgelegt.

  2. Wenden Sie das Manifest an:

    kubectl apply -f cb-percentage-based.yaml

  3. Prüfen Sie, ob GKE den Kapazitätspuffer angewendet hat:

    kubectl get capacitybuffer percentage-buffer -n NAMESPACE

    Prüfen Sie den Status des `CapacityBuffer`. Im Feld replicas sollte ein Wert aus der Prozentberechnung angezeigt werden. Wenn Sie das Deployment-Beispiel aus dem vorherigen Abschnitt verwenden, sollten Sie 2 Puffereinheiten sehen. Das entspricht 20% der 10 Replikate, die im Deployment definiert sind.

  4. Testen Sie die dynamische Skalierung, indem Sie das Deployment manuell auf 20 Replikate skalieren:

    kubectl scale deployment critical-workload-ref -n NAMESPACE --replicas=20

    Der `CapacityBuffer`-Controller reagiert und skaliert den Puffer automatisch auf 4 Replikate.

Puffer mit Ressourcenlimits konfigurieren

Mit dem Feld limits können Sie eine maximale Anzahl von Ressourcen definieren, die der Puffer verbrauchen soll. Diese wird basierend auf der Größe der PodTemplate berechnet.

So erstellen Sie einen Puffer mit Ressourcenlimits:

  1. Speichern Sie das folgende Manifest als cb-resource-limits.yaml:

    apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityBuffer
metadata:
  name: resource-limit-buffer
  namespace: NAMESPACE
spec:
  podTemplateRef:
    name: POD_TEMPLATE
  limits:
    cpu: "5"
    memory: "5Gi"

    Ersetzen Sie Folgendes:

    • NAMESPACE: Der Name Ihres Namespace, z. B. capacity-buffer-example.
    • POD_TEMPLATE: Die PodTemplate, die Ihre Ressourcenanforderungen definiert, z. B. buffer-unit-template.

    Dieses Manifest erstellt eine `CapacityBuffer`-Ressource mit einem Limit von insgesamt 5 CPUs und 5 GiB Arbeitsspeicher. Wenn Sie das PodTemplate Beispiel aus dem vorherigen Schritt verwenden, definieren Sie jede Einheit als 1 CPU und 1Gi Arbeitsspeicher. Das sollte zu 5 Puffereinheiten führen.

  2. Wenden Sie das Manifest an:

    kubectl apply -f cb-resource-limits.yaml

  3. Prüfen Sie, ob GKE den Kapazitätspuffer angewendet hat:

    kubectl get capacitybuffer resource-limit-buffer -n NAMESPACE

    Prüfen Sie den Status des `CapacityBuffer`. Im Feld replicas sollte ein Wert angezeigt werden, der von den von Ihnen definierten Limits abgeleitet wurde. Wenn Sie das PodTemplate-Beispiel aus dem vorherigen Abschnitt verwenden, sollten Sie 5 Puffereinheiten sehen. Das ist die maximale Anzahl von Einheiten, die innerhalb der definierten Limits liegen.

Kapazitätspuffer entfernen

Wenn Sie keinen Kapazitätspuffer mehr für Ihre Arbeitslasten benötigen, löschen Sie das `CapacityBuffer`-Objekt. Dadurch werden die Platzhalter-Pods entfernt und der Cluster Autoscaler kann die Knoten herunterskalieren.

kubectl delete capacitybuffer CAPACITY_BUFFER_NAME -n NAMESPACE

Ersetzen Sie CAPACITY_BUFFER_NAME durch den Namen des `CapacityBuffer`, den Sie löschen möchten.

Fehlerbehebung

Im folgenden Abschnitt finden Sie Informationen zur Behebung häufiger Probleme mit Kapazitätspuffern.

Kapazitätspuffer aufgrund des Abrechnungsmodells nicht bereit

Wenn Sie einen `CapacityBuffer` für eine Arbeitslast erstellen, die das Pod-basierte Abrechnungsmodell (Pay-per-Pod) verwendet, ist der Kapazitätspuffer nicht bereit für die Bereitstellung.

Prüfen Sie den Status des `CapacityBuffer`, um dieses Problem zu identifizieren:

kubectl describe capacitybuffer BUFFER_NAME -n NAMESPACE

Suchen Sie nach einer Bedingung vom Typ ReadyForProvisioning mit dem Status False.

Achten Sie darauf, dass Ihr `CapacityBuffer` auf eine Arbeitslast oder PodTemplate verweist, die mit der knotenbasierten Abrechnung kompatibel ist, um dieses Problem zu beheben.

Berechtigungsfehler für benutzerdefinierte skalierbare Ressourcen

Wenn Sie einen `CapacityBuffer` für die Verwendung mit benutzerdefinierten skalierbaren Objekten konfigurieren (mit dem Feld scalableRef), kann der Cluster Autoscaler den Puffer möglicherweise nicht skalieren, wenn er nicht die erforderlichen Berechtigungen hat.

Um dieses Problem zu beheben, gewähren Sie die erforderlichen Berechtigungen manuell, indem Sie eine ClusterRole und eine ClusterRoleBinding erstellen, wie im folgenden Beispiel:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: custom-scale-getter
rules:
- apiGroups: ["api.example.com"]
  resources: ["customreplicatedresources/scale"]
  verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: ca-custom-scale-getter
subjects:
- kind: User
  name: "system:cluster-autoscaler"
  namespace: kube-system
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: custom-scale-getter

Weitere Informationen zum Konfigurieren von RBAC finden Sie in der Kubernetes RBAC-Dokumentation.

Nächste Schritte