Compute-Klassen standardmäßig auf Pods anwenden

Autopilot Standard

In diesem Dokument wird beschrieben, wie Sie ComputeClasses standardmäßig auf Google Kubernetes Engine-Pods (GKE) anwenden, die keine ComputeClass explizit auswählen. Sie können eine ComputeClass als Standard für einen Namespace oder für einen gesamten Cluster festlegen. Dieses Dokument richtet sich an Clusteradministratoren, die den manuellen Aufwand reduzieren möchten, der durch die individuelle Konfiguration von Arbeitslasten und Knoten entsteht.

Sie sollten mit benutzerdefinierten ComputeClasses vertraut sein.

Informationen zu Standard-ComputeClasses

Sie können GKE-Cluster oder bestimmte Namespaces so konfigurieren, dass sie eine Standard -ComputeClass haben. Die von Ihnen konfigurierte Standardklasse gilt für alle Pods in diesem Cluster oder Namespace, die keine andere ComputeClass auswählen. Wenn Sie einen Pod bereitstellen, der keine ComputeClass auswählt, wendet GKE die Standard-ComputeClasses in der folgenden Reihenfolge an:

1. Wenn der Namespace eine Standard-ComputeClass hat, ändert GKE die Pod-Spezifikation, um diese ComputeClass auszuwählen.
2. Wenn der Namespace keine Standard-ComputeClass hat, gilt die Standardklasse auf Clusterebene. GKE ändert die Pod-Spezifikation nicht.

Wenn Sie eine Standard-ComputeClass für einen Cluster oder einen Namespace festlegen, gilt die Änderung nur für neue Pods. Vorhandene Pods sind erst betroffen, wenn sie neu erstellt werden. Dieses Verhalten gilt auch, wenn für Ihre ComputeClass die aktive Migration aktiviert ist.

Wenn für Ihre Standard-ComputeClass das Feld activeMigration.optimizeRulePriority auf true gesetzt ist, kann sich diese Einstellung auf Arbeitslasten in Ihren Clustern auswirken. Weitere Informationen finden Sie unter Aktive Migration in Standard-ComputeClasses.

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 gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.
  Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI das Attribut compute/region 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 GKE Autopilot- oder Standardcluster, auf dem eine Version ausgeführt wird, die das Festlegen einer Standard-ComputeClass auf Cluster- oder Namespace-Ebene unterstützt. Weitere Informationen finden Sie im Abschnitt Voraussetzungen.

• Wenn Sie einen Cluster im Standardmodus verwenden, müssen Sie eine der folgenden Voraussetzungen erfüllen:

  • Aktivieren Sie Autoscaling für mindestens einen Knotenpool im Cluster.
  • Wenn auf Ihrem Standardcluster eine Version vor 1.33.3-gke.1136000 ausgeführt wird und er nicht im Rapid-Release- Channel registriert ist, aktivieren Sie die automatische Knotenbereitstellung auf Clusterebene.

• Wenn Sie eine benutzerdefinierte ComputeClass als Standard für einen Namespace festlegen möchten, stellen Sie eine benutzerdefinierte ComputeClass bereit.

Voraussetzungen

• Wenn Sie eine ComputeClass als Standard auf Clusterebene festlegen möchten, muss auf dem Cluster die GKE-Version 1.33.1-gke.1744000 oder höher ausgeführt werden.
• Wenn Sie eine ComputeClass nur für Nicht-DaemonSet-Pods als Standard auf Namespace-Ebene festlegen möchten, muss auf dem Cluster die GKE-Version 1.33.1-gke.1788000 oder höher ausgeführt werden.

Erforderliche Rollen und Berechtigungen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Google Cloud Projekt zu gewähren, um die Berechtigungen zu erhalten, die Sie zum Konfigurieren von Standard-ComputeClasses auf Cluster- oder Namespace-Ebene benötigen:

• Kubernetes Engine-Entwickler (roles/container.developer)
• Standard-ComputeClass auf Clusterebene aktualisieren: Administrator für Kubernetes Engine-Cluster (roles/container.clusterAdmin)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Konfigurieren von Standard-ComputeClasses auf Cluster- oder Namespace-Ebene erforderlich sind. Maximieren Sie den Abschnitt Erforderliche Berechtigungen , um die notwendigen Berechtigungen anzuzeigen, die erforderlich sind:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um Standard-ComputeClasses auf Cluster- oder Namespace-Ebene zu konfigurieren:

• container.customResourceDefinitions.create
• container.customResourceDefinitions.update
• container.customResourceDefinitions.get
• container.customResourceDefinitions.list
• container.namespaces.get
• container.namespaces.list
• container.pods.get
• container.nodes.get
• container.nodes.list
• container.deployments.create
• container.deployments.get
• Labels zu Namespaces hinzufügen: container.namespaces.update
• Standard-ComputeClass auf Clusterebene aktivieren: container.clusters.update

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Standard-ComputeClass für einen Namespace konfigurieren

Sie können jeden Kubernetes-Namespace in Ihrem Cluster mit dem Namen einer ComputeClass annotieren, die als Standard verwendet werden soll. Wenn ein Pod, der in diesem Namespace bereitgestellt wird, noch keine ComputeClass ausgewählt hat, ändert GKE die Pod-Spezifikation, um die Standardklasse im Namespace auszuwählen. Sie können jede benutzerdefinierte oder integrierte ComputeClass als Standard festlegen.

• Wenn Sie standardmäßig eine ComputeClass auf alle Pods in einem Namespace anwenden möchten, fügen Sie diesem Namespace das Label cloud.google.com/default-compute-class hinzu:

  kubectl label namespaces NAMESPACE_NAME \
      cloud.google.com/default-compute-class=COMPUTECLASS_NAME
  

  Ersetzen Sie Folgendes:

  • NAMESPACE_NAME: der Name des Namespace, der aktualisiert werden soll.
  • COMPUTECLASS_NAME: der Name der ComputeClass, die als Standard für den Namespace festgelegt werden soll.

  Wenn der Befehl mit der folgenden Fehlermeldung fehlschlägt, hat der Namespace bereits eine Standard-ComputeClass:

  error: 'cloud.google.com/default-compute-class' already has a value, and --overwrite is false
  

  Aktualisieren Sie zur Behebung dieses Fehlers, die Standard-ComputeClass für den Namespace.

• Wenn Sie standardmäßig eine ComputeClass auf alle Nicht-DaemonSet-Pods in einem Namespace anwenden möchten, fügen Sie diesem Namespace das Label cloud.google.com/default-compute-class-non-daemonset hinzu:

  kubectl label namespaces NAMESPACE_NAME \
      cloud.google.com/default-compute-class-non-daemonset=COMPUTECLASS_NAME
  

  Wenn der Befehl mit der folgenden Fehlermeldung fehlschlägt, hat der Namespace bereits eine Standard-ComputeClass für Nicht-DaemonSet-Pods:

  error: 'cloud.google.com/default-compute-class-non-daemonset' already has a value, and --overwrite is false
  

  Aktualisieren Sie zur Behebung dieses Fehlers, die Standard-ComputeClass für den Namespace.

Ihre Änderungen gelten für alle neuen Pods in diesem Namespace. Vorhandene Pods sind davon nicht betroffen.

Vorhandene Standard-ComputeClass in einem Namespace aktualisieren

Führen Sie einen der folgenden Befehle aus, um die vorhandene Standard-ComputeClass für einen Namespace zu überschreiben:

• Standard-ComputeClass für alle Pods im Namespace aktualisieren:

  kubectl label namespaces NAMESPACE_NAME   \
      cloud.google.com/default-compute-class=COMPUTECLASS_NAME \
      --overwrite
  

  Ersetzen Sie Folgendes:

  • NAMESPACE_NAME: der Name des Namespace, der aktualisiert werden soll.
  • COMPUTECLASS_NAME: der Name der ComputeClass, die als neuer Standard für den Namespace festgelegt werden soll.

• Standard-ComputeClass für Nicht-DaemonSet-Pods im Namespace überschreiben:

  kubectl label namespaces NAMESPACE_NAME \
      cloud.google.com/default-compute-class-non-daemonset=COMPUTECLASS_NAME \
      --overwrite
  

Standard-ComputeClass für System-Namespaces konfigurieren

GKE verwendet System-Namespaces, um verschiedene verwaltete Arbeitslasten wie Überwachungs-Agents auszuführen. Einige dieser verwalteten Arbeitslasten sind DaemonSets, die auf jedem Knoten im Cluster ausgeführt werden müssen, um kritische Funktionen bereitzustellen. Sie können jedoch eine Standard-ComputeClass für Nicht-DaemonSet-Pods in System-Namespaces angeben, damit diese Pods getrennt von Ihren Arbeitslasten ausgeführt werden.

So legen Sie eine Standard-ComputeClass für System-Namespaces fest:

1. Speichern Sie das folgende Skript als apply-system-cc.sh. Mit diesem Skript können Sie eine empfohlene ComputeClass oder Ihre eigene vorhandene ComputeClass auf System-Namespaces anwenden.

   #!/bin/bash
   
   # The recommended default ComputeClass name for system pods.
   DEFAULT_SYSTEM_CC_NAME="system-default-computeclass"
   
   # The YAML manifest for the recommended default ComputeClass for system pods.
   read -r -d '' DEFAULT_CC_YAML << EOF
   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: ${DEFAULT_SYSTEM_CC_NAME}
   spec:
     nodePoolAutoCreation:
       enabled: true
     whenUnsatisfiable: ScaleUpAnyway
     priorities:
     - machineFamily: t2d
   EOF
   
   # The label key to apply to namespaces.
   LABEL_KEY="cloud.google.com/default-compute-class-non-daemonset"
   
   
   # List of GKE system namespaces.
   SYSTEM_NAMESPACES=(
     "kube-system"
     "gke-gmp-system"
     "gmp-system"
     "gke-managed-cim"
     "gke-managed-volumepopulator"
     "gke-managed-checkpointing"
     "gkebackup"
     "gke-managed-lustrecsi"
   )
   
   
   # 1. Ask the user for their choice.
   echo "This script sets a default ComputeClass for GKE system namespaces."
   echo "--------------------------------------------------------------------"
   echo "The following ComputeClass is recommended for system Pods:"
   echo ""
   echo "$DEFAULT_CC_YAML"
   echo "--------------------------------------------------------------------"
   read -p "Do you want to use the recommended ComputeClass? (y/N): " user_choice
   
   CC_TO_APPLY=""
   
   # 2. Process the user's choice.
   if [[ "$user_choice" =~ ^[Yy]$ ]]; then
     # Path 1: User chose YES.
     echo "Installing the recommended default ComputeClass '${DEFAULT_SYSTEM_CC_NAME}'..."
   
     if ! echo "$DEFAULT_CC_YAML" | kubectl apply -f -; then
         # If kubectl apply fails, print an error and exit.
         echo "❌ Error: Failed to create the default ComputeClass. An internal error occurred."
         echo "Check for kubectl permissions or other cluster issues and re-run the script."
         exit 1
     fi
     # If the command succeeded, set the name to be used for labeling.
     CC_TO_APPLY="$DEFAULT_SYSTEM_CC_NAME"
   
   else
     read -p "Specify the name of an existing ComputeClass to set as the default for system Pods: " custom_cc_name
   
     # Validate that the user entered a name.
     while [[ -z "$custom_cc_name" ]]; do
       echo "Error: Name cannot be empty."
       read -p "Specify the name of an existing ComputeClass: " custom_cc_name
     done
   
     # Check if the specified ComputeClass actually exists in the cluster.
     echo "--> Verifying that ComputeClass '${custom_cc_name}' exists..."
     if kubectl get computeclass "$custom_cc_name" > /dev/null 2>&1; then
       echo "Verified."
       CC_TO_APPLY="$custom_cc_name"
     else
       echo "Error: ComputeClass '${custom_cc_name}' doesn't exist in the cluster."
       echo "Create the ComputeClass, and then then re-run this script."
       exit 1
     fi
   fi
   
   echo ""
   echo "Labelling system namespaces with ComputeClass: '${CC_TO_APPLY}'"
   echo "--------------------------------------------------------------------"
   
   # 3. Apply the label to all system namespaces.
   for ns in "${SYSTEM_NAMESPACES[@]}"; do
     # Gracefully handle namespaces that don't exist on this specific cluster.
     if kubectl get namespace "${ns}" > /dev/null 2>&1; then
       echo "--> Applying label to namespace: ${ns}"
       kubectl label namespace "${ns}" \
         "${LABEL_KEY}=${CC_TO_APPLY}" --overwrite
     else
       echo "--> Skipping namespace ${ns} (does not exist)"
     fi
   done
   
   echo ""
   echo "✅ Script finished successfully."

   Dieses Skript verwendet das Label cloud.google.com/default-compute-class-non-daemonset, das sich nur auf Nicht-DaemonSet-Pods in System-Namespaces auswirkt.

   Warnung: Legen Sie das Label cloud.google.com/default-compute-class nicht für einen System-Namespace fest. Dieses Label wirkt sich auf DaemonSets aus und kann zu Unterbrechungen in Ihrem Cluster führen.

2. Führen Sie das Script aus:

   ./apply-system-cc.sh
   

Nach Abschluss des Skripts verwenden alle neuen Nicht-DaemonSet-System-Pods standardmäßig die angegebene ComputeClass, es sei denn, sie haben bereits eine ComputeClass. Vorhandene Pods in diesen Namespaces sind davon nicht betroffen. Wenn GKE neue System-Namespaces hinzufügt, führen Sie dieses Skript noch einmal aus, um die Änderungen auf diese Namespaces anzuwenden.

So heben Sie die Standard-ComputeClass für System-Namespaces auf:

1. Speichern Sie das folgende Skript als unset-system-cc.sh:

   #!/bin/bash
   
   # The recommended default ComputeClass name for system pods.
   DEFAULT_SYSTEM_CC_NAME="system-default-computeclass"
   
   # The YAML manifest for the recommended default ComputeClass for system pods.
   read -r -d '' DEFAULT_CC_YAML << EOF
   apiVersion: cloud.google.com/v1
   kind: ComputeClass
   metadata:
     name: ${DEFAULT_SYSTEM_CC_NAME}
   spec:
     nodePoolAutoCreation:
       enabled: true
     whenUnsatisfiable: ScaleUpAnyway
     priorities:
     - machineFamily: t2d
   EOF
   
   # The label key to apply to namespaces.
   LABEL_KEY="cloud.google.com/default-compute-class-non-daemonset"
   
   
   # List of GKE system namespaces.
   SYSTEM_NAMESPACES=(
     "kube-system"
     "gke-gmp-system"
     "gmp-system"
     "gke-managed-cim"
     "gke-managed-volumepopulator"
     "gke-managed-checkpointing"
     "gkebackup"
     "gke-managed-lustrecsi"
   )
   
   
   # 1. Ask the user for their choice.
   echo "This script sets a default ComputeClass for GKE system namespaces."
   echo "--------------------------------------------------------------------"
   echo "The following ComputeClass is recommended for system Pods:"
   echo ""
   echo "$DEFAULT_CC_YAML"
   echo "--------------------------------------------------------------------"
   read -p "Do you want to use the recommended ComputeClass? (y/N): " user_choice
   
   CC_TO_APPLY=""
   
   # 2. Process the user's choice.
   if [[ "$user_choice" =~ ^[Yy]$ ]]; then
     # Path 1: User chose YES.
     echo "Installing the recommended default ComputeClass '${DEFAULT_SYSTEM_CC_NAME}'..."
   
     if ! echo "$DEFAULT_CC_YAML" | kubectl apply -f -; then
         # If kubectl apply fails, print an error and exit.
         echo "❌ Error: Failed to create the default ComputeClass. An internal error occurred."
         echo "Check for kubectl permissions or other cluster issues and re-run the script."
         exit 1
     fi
     # If the command succeeded, set the name to be used for labeling.
     CC_TO_APPLY="$DEFAULT_SYSTEM_CC_NAME"
   
   else
     read -p "Specify the name of an existing ComputeClass to set as the default for system Pods: " custom_cc_name
   
     # Validate that the user entered a name.
     while [[ -z "$custom_cc_name" ]]; do
       echo "Error: Name cannot be empty."
       read -p "Specify the name of an existing ComputeClass: " custom_cc_name
     done
   
     # Check if the specified ComputeClass actually exists in the cluster.
     echo "--> Verifying that ComputeClass '${custom_cc_name}' exists..."
     if kubectl get computeclass "$custom_cc_name" > /dev/null 2>&1; then
       echo "Verified."
       CC_TO_APPLY="$custom_cc_name"
     else
       echo "Error: ComputeClass '${custom_cc_name}' doesn't exist in the cluster."
       echo "Create the ComputeClass, and then then re-run this script."
       exit 1
     fi
   fi
   
   echo ""
   echo "Labelling system namespaces with ComputeClass: '${CC_TO_APPLY}'"
   echo "--------------------------------------------------------------------"
   
   # 3. Apply the label to all system namespaces.
   for ns in "${SYSTEM_NAMESPACES[@]}"; do
     # Gracefully handle namespaces that don't exist on this specific cluster.
     if kubectl get namespace "${ns}" > /dev/null 2>&1; then
       echo "--> Applying label to namespace: ${ns}"
       kubectl label namespace "${ns}" \
         "${LABEL_KEY}=${CC_TO_APPLY}" --overwrite
     else
       echo "--> Skipping namespace ${ns} (does not exist)"
     fi
   done
   
   echo ""
   echo "✅ Script finished successfully."

2. Führen Sie das Script aus:

   ./unset-system-cc.sh
   

Standard-ComputeClass für einen Cluster konfigurieren

Sie können jede benutzerdefinierte ComputeClass als Standard für Ihren gesamten Cluster festlegen. Dazu müssen Sie Standard-ComputeClasses auf Clusterebene in Ihrem Cluster aktivieren und dann eine ComputeClass mit dem Namen default erstellen. Sie können sogar das Verhalten der integrierten Autopilot-ComputeClasses erzielen, indem Sie dieselben Prioritätsregeln in einer ComputeClass mit dem Namen defaultangeben.

Best Practice: Wenn Sie eine Standard-ComputeClass auf Clusterebene festlegen, fügen Sie vorhandenen Knotenpools im Cluster keine ComputeClass-Knotenlabels und -Taints hinzu. GKE skaliert Knotenpools mit Knotentaints für andere ComputeClasses nicht, wenn Pods geplant werden, die die Standard-ComputeClass auf Clusterebene verwenden.

Sie müssen beide folgenden Schritte ausführen, um eine Standard-ComputeClass in Ihrem Cluster korrekt zu verwenden:

1. Wenn Sie eine Standard-ComputeClass auf Clusterebene für einen Cluster festlegen möchten, verwenden Sie das --enable-default-compute-class Flag wenn Sie einen Cluster erstellen oder aktualisieren:

   • Cluster erstellen:

     gcloud container clusters create CLUSTER_NAME \
         --location=CONTROL_PLANE_LOCATION \
         --enable-default-compute-class
     

     Ersetzen Sie Folgendes:

     • CLUSTER_NAME: ein Name für Ihren Cluster.
     • CONTROL_PLANE_LOCATION: der Standort Ihrer Cluster-Steuerungsebene, z. B. us-central1.

   • Cluster aktualisieren:

     gcloud container clusters update CLUSTER_NAME \
         --location=CONTROL_PLANE_LOCATION \
         --enable-default-compute-class
     

     Ersetzen Sie Folgendes:

     • CLUSTER_NAME: der Name Ihres Clusters.
     • CONTROL_PLANE_LOCATION: der Standort Ihrer Cluster-Steuerungsebene, z. B. us-central1.

   Nachdem Sie diesen Schritt ausgeführt haben, sucht GKE in Ihrem Cluster nach einer ComputeClass mit dem Namen default. Sie werden erst Änderungen an Ihren Arbeitslasten feststellen, wenn Sie die ComputeClass default eingerichtet haben.

2. Erstellen Sie eine ComputeClass mit dem Namen default, wie in den folgenden Beispielen:

   • Die folgende ComputeClass fordert bestimmte Maschinenreihen an:

     apiVersion: cloud.google.com/v1
     kind: ComputeClass
     metadata:
       name: default
     spec:
       priorities:
       - machineFamily: n4
       - machineFamily: n2
       whenUnsatisfiable: ScaleUpAnyway
       nodePoolAutoCreation:
         enabled: true
     

     Diese ComputeClass fordert Knoten an, die N4-Instanzen verwenden. Wenn keine N4-Instanzen verfügbar sind, fordert die ComputeClass stattdessen N2-Instanzen an. Sie können die default ComputeClass mit allen verfügbaren Feldern in der ComputeClass-CustomResourceDefinition konfigurieren.

   • Die folgende ComputeClass fordert die containeroptimierte Compute-Plattform von Autopilot an:

     apiVersion: cloud.google.com/v1
     kind: ComputeClass
     metadata:
       name: default
     spec:
       autopilot:
         enabled: true
       priorities:
       - podFamily: general-purpose
       whenUnsatisfiable: ScaleUpAnyway
     

     Diese ComputeClass entspricht dem Verhalten der integrierten ComputeClass autopilot, mit Ausnahme des Felds whenUnsatisfiable, das den Wert ScaleUpAnyway anstelle von DoNotScaleUp hat. Diese Änderung trägt dazu bei, Situationen zu vermeiden, in denen Pods, die einen Knotenselektor für bestimmte Hardware verwenden, im Status „Ausstehend“ bleiben, weil die Standard-ComputeClass auf Clusterebene auf diese Pods angewendet wurde.

     Die Prioritätsregel podFamily platziert Pods auf der containeroptimierten Compute-Plattform von Autopilot. Für diese Prioritätsregel ist die GKE-Version 1.35.2-gke.1485000 oder höher erforderlich.

3. Erstellen Sie die ComputeClass default in Ihrem Cluster:

   kubectl apply -f PATH_TO_MANIFEST
   

   Ersetzen Sie PATH_TO_MANIFEST durch den Pfad zum Manifest für die ComputeClass.

4. Optional: Wenn Ihr Standardcluster bereits manuell erstellte Knotenpools hat, die Sie als Standard für Ihre Arbeitslasten für allgemeine Zwecke verwenden, können Sie diese Arbeitslasten in den Autopilot-Modus verschieben, nachdem Sie eine Autopilot-ComputeClass als Standard auf Clusterebene festgelegt haben. Sperren und leeren Sie dazu alle Knoten in den Knotenpools. GKE verwendet die Standard-ComputeClass auf Clusterebene, um die neuen ausstehenden Pods zu planen.

Nachdem Sie eine Standard-ComputeClass auf Clusterebene festgelegt haben, skaliert GKE Knotenpools, die beide folgenden Voraussetzungen erfüllen:

• Die Knotenkonfiguration ist dieselbe wie die Konfiguration der ComputeClass default.
• Der Knotenpool hat keine Taints oder Labels für eine andere ComputeClass. GKE kann Knotenpools skalieren, die einen Taint und ein Label für die ComputeClass default haben.

Wenn die ComputeClass default beispielsweise die Maschinenreihe N4 angibt, kann GKE einen vorhandenen Knotenpool skalieren, der N4-Instanzen verwendet und keine Taints oder Labels für eine andere ComputeClass hat.

Ihre Änderungen gelten für alle neuen Pods im Cluster, die noch keine ComputeClass haben. Vorhandene Pods können je nach den Einstellungen für die aktive Migration der Standard-ComputeClass auf Clusterebene betroffen sein. Weitere Informationen finden Sie unter Aktive Migration in Standard-ComputeClasses.

Verhalten der Standard-ComputeClass prüfen

So prüfen Sie, ob die Standard-ComputeClass, die Sie für einen Namespace oder einen Cluster festgelegt haben, wie erwartet funktioniert:

1. Sehen Sie sich das folgende Beispiel-Deployment an:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: helloweb
     labels:
       app: hello
   spec:
     selector:
       matchLabels:
         app: hello
         tier: web
     template:
       metadata:
         labels:
           app: hello
           tier: web
       spec:
         containers:
         - name: hello-app
           image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
           ports:
           - containerPort: 8080
           resources:
             requests:
               cpu: 200m

   Dieses Deployment fordert keine ComputeClass explizit an.

2. Erstellen Sie das Deployment:

   kubectl apply --namespace=NAMESPACE_NAME \
       -f https://raw.githubusercontent.com/GoogleCloudPlatform/kubernetes-engine-samples/refs/heads/main/quickstarts/hello-app/manifests/helloweb-deployment.yaml
   

   Ersetzen Sie NAMESPACE_NAME durch einen der folgenden Werte, je nachdem, was Sie prüfen möchten:

   • Der Name eines Namespace mit einer Standard-ComputeClass.
   • Der Name eines Namespace ohne Standard-ComputeClass.

   Es kann einige Zeit dauern, bis GKE neue Knoten erstellt hat, um die Pods auszuführen.

3. Ermitteln Sie die Knoten, auf denen die Pods aus dem Beispiel-Deployment ausgeführt werden:

   kubectl get pods --namespace=NAMESPACE_NAME \
       --selector=app=hello -o=wide
   

   Die Ausgabe sieht etwa so aus:

   NAME                        READY   STATUS    RESTARTS   AGE     IP          NODE                                                  NOMINATED NODE   READINESS GATES
   helloweb-7795fbf856-58n5l   1/1     Running   0          9m21s   10.52.2.3   gke-cluster-1-nap-n2-highcpu-2-3muqi8-f213e529-rx7d   <none>           <none>
   

4. Rufen Sie die Knotenlabels ab:

   kubectl get node NODE_NAME --show-labels \
       | grep "cloud.google.com/compute-class"
   

   Ersetzen Sie NODE_NAME durch den Namen des Knotens aus der Ausgabe des vorherigen Schritts.

   Die Ausgabe sieht etwa so aus:

   NODE_NAME   Ready    <none>   22m   v1.32.4-gke.1236007
   # lines are omitted from this output
   cloud.google.com/compute-class=COMPUTECLASS_NAME,cloud.google.com/gke-boot-disk=pd-balanced,cloud.google.com/gke-container-runtime=containerd
   

   Der Wert in COMPUTECLASS_NAME ist einer der folgenden:

   • Standard-ComputeClass auf Clusterebene: default für Knoten, die von GKE Autopilot oder durch die automatische Erstellung von Knotenpools erstellt wurden. Knoten in vorhandenen manuell erstellten Knotenpools haben möglicherweise nicht das Label cloud.google.com/compute-class.
   • Standard-ComputeClass auf Namespace-Ebene: der Name der ComputeClass die Sie als Standard für den Namespace konfiguriert haben.

Standard-ComputeClass deaktivieren

Führen Sie einen der folgenden Schritte aus, um die Standard-ComputeClass in einem Namespace oder einem Cluster zu deaktivieren:

• Wenn Sie die Standard-ComputeClass auf Namespace-Ebene für alle Pods deaktivieren möchten, entfernen Sie das Label cloud.google.com/default-compute-class aus dem Namespace:

  kubectl label namespaces NAMESPACE_NAME \
    cloud.google.com/default-compute-class-
  

  Das Zeichen - am Ende des Labelschlüssels entfernt alle Labels mit diesem Schlüssel aus dem Objekt Namespace in der Kubernetes API.

• Wenn Sie die Standard-ComputeClass auf Namespace-Ebene für Nicht-DaemonSet-Pods deaktivieren möchten, entfernen Sie das Label cloud.google.com/default-compute-class-non-daemonset aus dem Namespace:

  kubectl label namespaces NAMESPACE_NAME \
    cloud.google.com/default-compute-class-non-daemonset-
  

• Wenn Sie die Standard-ComputeClass auf Clusterebene deaktivieren möchten, verwenden Sie den Befehl gcloud container clusters update mit dem Flag --no-enable-default-compute-class:

  gcloud container clusters update CLUSTER_NAME \
      --location=CONTROL_PLANE_LOCATION \
      --no-enable-default-compute-class
  

Nächste Schritte

• Weitere Informationen zu benutzerdefinierten ComputeClasses in GKE.