Diese Seite wurde von der Cloud Translation API übersetzt.

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, für die keine ComputeClass explizit ausgewählt ist. Auf dieser Seite finden Sie eine Anleitung zum Festlegen einer ComputeClass als Standard in einem Namespace und für einen gesamten Cluster. Dieses Dokument richtet sich an Clusteradministratoren, die den manuellen Aufwand für die Konfiguration einzelner Arbeitslasten und Knoten reduzieren möchten.

Sie sollten mit benutzerdefinierten Compute-Klassen vertraut sein.

Standard-Compute-Klassen

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, für die keine andere ComputeClass ausgewählt ist. Wenn Sie einen Pod bereitstellen, für den keine ComputeClass ausgewählt ist, wendet GKE Standard-ComputeClasses in der folgenden Reihenfolge an:

Wenn der Namespace eine Standard-ComputeClass hat, ändert GKE die Pod-Spezifikation, um diese ComputeClass auszuwählen.
Wenn für den Namespace keine Standard-ComputeClass festgelegt ist, wird die Standardklasse auf Clusterebene angewendet. 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 dann, wenn für Ihre ComputeClass die aktive Migration aktiviert ist.

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

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 diesen Task 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 haben einen GKE Autopilot- oder Standard-Cluster, in 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 Anforderungen.
Wenn Sie einen Cluster im Standardmodus verwenden, muss eine der folgenden Anforderungen erfüllt sein:
- 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 für den 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

Damit Sie eine ComputeClass als Standard auf Clusterebene festlegen können, muss auf dem Cluster die GKE-Version 1.33.1-gke.1744000 oder höher ausgeführt werden.
Wenn Sie eine ComputeClass als Standard auf Namespace-Ebene nur für Nicht-DaemonSet-Pods festlegen möchten, muss im 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 zuzuweisen, damit Sie die Berechtigungen erhalten, die Sie zum Konfigurieren von Standard-ComputeClasses auf Cluster- oder Namespace-Ebene benötigen:

Kubernetes Engine-Entwickler (roles/container.developer)
Aktualisieren Sie die Standard-ComputeClass auf Clusterebene: 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:

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 für einen Pod, der in diesem Namespace bereitgestellt wird, noch keine ComputeClass ausgewählt ist, ändert GKE die Pod-Spezifikation, um die Standardklasse im Namespace auszuwählen. Sie können eine beliebige benutzerdefinierte oder integrierte ComputeClass als Standard festlegen.

Wenn Sie eine ComputeClass standardmäßig 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 die Standard-ComputeClass für den Namespace, um diesen Fehler zu beheben.
Wenn Sie eine ComputeClass standardmäßig 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 die Standard-ComputeClass für den Namespace, um diesen Fehler zu beheben.

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:

Aktualisieren Sie die Standard-ComputeClass für alle Pods im Namespace:
```
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.

Überschreiben Sie die Standard-ComputeClass für Nicht-DaemonSet-Pods im Namespace:

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 Monitoring-Agents auszuführen. Einige dieser verwalteten Arbeitslasten sind DaemonSets, die auf jedem Knoten im Cluster ausgeführt werden müssen, um wichtige 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:

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.

Führen Sie das Script aus:
```
./apply-system-cc.sh
```

Nachdem das Skript abgeschlossen ist, verwenden alle neuen System-Pods, die keine DaemonSets sind, standardmäßig die angegebene ComputeClass, sofern sie nicht bereits eine ComputeClass haben. 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 Änderungen auf diese Namespaces anzuwenden.

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

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."

Führen Sie das Script aus:
```
./unset-system-cc.sh
```

Compute-Standardklasse für einen Cluster konfigurieren

In diesem Abschnitt erfahren Sie, wie Sie eine ComputeClass als Standard für Ihren Cluster festlegen. Bei Standard-Compute-Klassen auf Clusterebene sollten Sie Knotenmarkierungen und Knotenlabels für vorhandene Knotenpools im Cluster nicht manuell angeben. GKE skaliert keine Knotenpools, die Knotenmarkierungen für Compute-Klassen haben. Wenn Sie manuell ein Label für die default ComputeClass hinzufügen, kann GKE diesen Knotenpool skalieren. Diese manuelle Konfiguration ist jedoch nicht erforderlich, um eine Standard-Compute-Klasse auf Clusterebene zu verwenden.

Wenn Sie eine Standard-ComputeClass auf Clusterebene für einen Cluster festlegen möchten, führen Sie den Befehl gcloud container clusters update mit dem Flag --enable-default-compute-class aus:
```
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 der Cluster-Steuerungsebene, z. B. us-central1.
Sie können dieses Flag auch angeben, wenn Sie einen Autopilot- oder Standardcluster erstellen.
Speichern Sie das folgende Manifest, in dem ein ComputeClass mit dem Namen default definiert wird:
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: default
spec:
  priorities:
  - machineFamily: n4
  - machineFamily: n2
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
In diesem Beispielmanifest werden Knoten angefordert, die N4-Instanzen verwenden. Wenn keine N4-Instanzen verfügbar sind, werden stattdessen N2-Instanzen angefordert. Sie können die default ComputeClass mit einem der verfügbaren Felder in der CustomResourceDefinition für ComputeClass konfigurieren.
Wenden Sie das Manifest auf Ihren Cluster an:
```
kubectl apply -f PATH_TO_MANIFEST
```
Ersetzen Sie PATH_TO_MANIFEST durch den Pfad zum Manifest für die ComputeClass.

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

Die Knotenkonfiguration entspricht der Konfiguration der defaultComputeClass.
Der Knotenpool hat keine Taints oder Labels für eine andere ComputeClass. GKE kann Knotenpools skalieren, die eine Markierung und ein Label für die Compute-Klasse default haben.

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

Ihre Änderungen werden auf alle neuen Pods im Cluster angewendet, die noch keine ComputeClass haben. Vorhandene Pods können je nach den aktiven Migrationseinstellungen der Standard-ComputeClass auf Clusterebene betroffen sein. Weitere Informationen finden Sie unter Aktive Migration in Standard-ComputeClasses.

Standardverhalten der 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:

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

In diesem Deployment wird keine ComputeClass explizit angefordert.

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 bestätigen möchten:
- Der Name eines Namespace mit einer Standard-ComputeClass.
- Der Name eines Namespace, für den keine Standard-ComputeClass festgelegt ist.
Es kann einige Zeit dauern, bis GKE neue Knoten zum Ausführen der Pods erstellt.

Ermitteln Sie die Knoten, auf denen die Pods des Beispiel-Deployments 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>

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:
- Standardmäßige ComputeClass auf Clusterebene: default für Knoten, die von GKE Autopilot oder durch automatisches Erstellen 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

Wenn Sie die Standard-ComputeClass in einem Namespace oder Cluster deaktivieren möchten, haben Sie folgende Möglichkeiten:

Wenn Sie die Standard-Compute-Klasse 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 Namespace-Objekt 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-
```
Verwenden Sie den Befehl gcloud container clusters update mit dem Flag --no-enable-default-compute-class, um die Standard-ComputeClass auf Clusterebene zu deaktivieren:
```
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