Applica ComputeClasses ai pod per impostazione predefinita

Autopilot Standard

Questo documento mostra come applicare ComputeClass per impostazione predefinita ai pod Google Kubernetes Engine (GKE) che non selezionano esplicitamente una ComputeClass. Puoi impostare una ComputeClass come predefinita per uno spazio dei nomi o per un intero cluster. Questo documento è destinato agli amministratori dei cluster che vogliono ridurre il sovraccarico manuale causato dalla configurazione dei singoli nodi e workload.

Dovresti già avere familiarità con le ComputeClass personalizzate.

Informazioni sulle ComputeClass predefinite

Puoi configurare i cluster GKE o spazi dei nomi specifici in modo che abbiano una ComputeClass predefinita. La classe predefinita che configuri si applica a qualsiasi pod nel cluster o nello spazio dei nomi che non seleziona una ComputeClass diversa. Quando esegui il deployment di un pod che non seleziona una ComputeClass, GKE applica le ComputeClass predefinite nel seguente ordine:

Se lo spazio dei nomi ha una ComputeClass predefinita, GKE modifica la specifica del pod per selezionare quella ComputeClass.
Se lo spazio dei nomi non ha una ComputeClass predefinita, si applica la classe predefinita a livello di cluster. GKE non modifica la specifica del pod.

Quando imposti una ComputeClass predefinita per un cluster o uno spazio dei nomi, la modifica si applica solo ai nuovi pod. I pod esistenti non sono interessati finché non vengono ricreati. Questo comportamento si applica anche se la ComputeClass ha la migrazione attiva abilitata.

Se la ComputeClass predefinita ha il campo activeMigration.optimizeRulePriority impostato su true, questa impostazione potrebbe influire sui workload nei cluster. Per saperne di più, consulta Migrazione attiva nelle ComputeClass predefinite.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

Abilita l'API Google Kubernetes Engine.

Abilita l'API Google Kubernetes Engine

Se vuoi utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il gcloud components update comando. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.
Nota: per le installazioni esistenti di gcloud CLI assicurati di impostare la compute/region proprietà. Se utilizzi principalmente cluster zonali, imposta invece compute/zone. Se imposti una località predefinita, puoi evitare errori in gcloud CLI come il seguente: One of [--zone, --region] must be supplied: Please specify location. Potresti dover specificare la posizione in determinati comandi se la posizione del cluster è diversa da quella predefinita che hai impostato.

Disponi di un cluster GKE Autopilot o Standard che esegue una versione che supporta l'impostazione di una ComputeClass predefinita a livello di cluster o spazio dei nomi. Per saperne di più, consulta la sezione Requisiti.
Se utilizzi un cluster in modalità Standard, assicurati di soddisfare uno dei seguenti requisiti:
- Abilita la scalabilità automatica in almeno un pool di nodi nel cluster.
- Se il cluster Standard esegue una versione precedente alla 1.33.3-gke.1136000 e non è registrato nel canale di rilascio rapido, abilita il provisioning automatico dei nodi a livello di cluster.
Se vuoi impostare una ComputeClass personalizzata come predefinita per uno spazio dei nomi, esegui il deployment di una ComputeClass personalizzata.

Requisiti

Per impostare una ComputeClass come predefinita a livello di cluster, il cluster deve eseguire la versione GKE 1.33.1-gke.1744000 o versioni successive.
Per impostare una ComputeClass come predefinita a livello di spazio dei nomi solo per i pod non DaemonSet, il cluster deve eseguire la versione GKE 1.33.1-gke.1788000 o versioni successive.

Ruoli e autorizzazioni richiesti

Per ottenere le autorizzazioni necessarie per configurare le ComputeClass predefinite a livello di cluster o spazio dei nomi, chiedi all'amministratore di concederti i seguenti ruoli IAM sul Google Cloud progetto:

Sviluppatore Kubernetes Engine (roles/container.developer)
Aggiorna la ComputeClass predefinita a livello di cluster: Amministratore cluster Kubernetes Engine (roles/container.clusterAdmin)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per configurare le ComputeClass predefinite a livello di cluster o spazio dei nomi. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per configurare le ComputeClass predefinite a livello di cluster o spazio dei nomi sono necessarie le seguenti autorizzazioni:

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
Aggiungi etichette agli spazi dei nomi: container.namespaces.update
Abilita la ComputeClass predefinita a livello di cluster: container.clusters.update

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Configurare una ComputeClass predefinita per uno spazio dei nomi

Puoi annotare qualsiasi spazio dei nomi Kubernetes nel cluster con il nome di una ComputeClass da utilizzare come predefinita. Se un pod di cui è stato eseguito il deployment in quello spazio dei nomi non seleziona già una ComputeClass, GKE modifica la specifica del pod per selezionare la classe predefinita nello spazio dei nomi. Puoi impostare qualsiasi ComputeClass personalizzata o integrata come predefinita.

Per applicare una ComputeClass a tutti i pod in uno spazio dei nomi per impostazione predefinita, aggiungi l'etichetta cloud.google.com/default-compute-class a quello spazio dei nomi:
```
kubectl label namespaces NAMESPACE_NAME \
    cloud.google.com/default-compute-class=COMPUTECLASS_NAME
```
Sostituisci quanto segue:
- NAMESPACE_NAME: il nome dello spazio dei nomi da aggiornare.
- COMPUTECLASS_NAME: il nome della ComputeClass da impostare come predefinita per lo spazio dei nomi.
Se il comando non riesce e viene visualizzato il seguente messaggio di errore, lo spazio dei nomi ha già una ComputeClass predefinita:
```
error: 'cloud.google.com/default-compute-class' already has a value, and --overwrite is false
```
Per risolvere questo errore, aggiorna la ComputeClass predefinita per lo spazio dei nomi.
Per applicare una ComputeClass a tutti i pod non DaemonSet in uno spazio dei nomi per impostazione predefinita, aggiungi l'etichetta cloud.google.com/default-compute-class-non-daemonset a quello spazio dei nomi:
```
kubectl label namespaces NAMESPACE_NAME \
    cloud.google.com/default-compute-class-non-daemonset=COMPUTECLASS_NAME
```
Se il comando non riesce e viene visualizzato il seguente messaggio di errore, lo spazio dei nomi ha già una ComputeClass predefinita per i pod non DaemonSet:
```
error: 'cloud.google.com/default-compute-class-non-daemonset' already has a value, and --overwrite is false
```
Per risolvere questo errore, aggiorna la ComputeClass predefinita per lo spazio dei nomi.

Le modifiche si applicano a tutti i nuovi pod in quello spazio dei nomi. I pod esistenti non sono interessati.

Aggiornare la ComputeClass predefinita esistente in uno spazio dei nomi

Per sovrascrivere la ComputeClass predefinita esistente per uno spazio dei nomi, esegui uno dei seguenti comandi:

Aggiorna la ComputeClass predefinita per tutti i pod nello spazio dei nomi:
```
kubectl label namespaces NAMESPACE_NAME   \
    cloud.google.com/default-compute-class=COMPUTECLASS_NAME \
    --overwrite
```
Sostituisci quanto segue:
- NAMESPACE_NAME: il nome dello spazio dei nomi da aggiornare.
- COMPUTECLASS_NAME: il nome della ComputeClass da impostare come nuova predefinita per lo spazio dei nomi.

Sovrascrivi la ComputeClass predefinita per i pod non DaemonSet nello spazio dei nomi:

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

Configurare una ComputeClass predefinita per gli spazi dei nomi di sistema

GKE utilizza gli spazi dei nomi di sistema per eseguire vari workload gestiti, come gli agent di monitoraggio. Alcuni di questi workload gestiti sono DaemonSet, che devono essere eseguiti su ogni nodo del cluster per fornire funzionalità critiche. Tuttavia, puoi specificare una ComputeClass predefinita per i pod non DaemonSet negli spazi dei nomi di sistema, in modo che questi pod vengano eseguiti separatamente dai tuoi workload.

Per impostare una ComputeClass predefinita per gli spazi dei nomi di sistema:

Salva il seguente script come apply-system-cc.sh. Questo script ti consente di applicare una ComputeClass consigliata o una ComputeClass esistente agli spazi dei nomi di sistema.

#!/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."

Questo script utilizza l'etichetta cloud.google.com/default-compute-class-non-daemonset, che influisce solo sui pod non DaemonSet negli spazi dei nomi di sistema.

Esegui lo script:
```
./apply-system-cc.sh
```

Al termine dello script, tutti i nuovi pod di sistema non DaemonSet utilizzano la ComputeClass specificata per impostazione predefinita, a meno che non ne abbiano già una. I pod esistenti in questi spazi dei nomi non sono interessati. Se GKE aggiunge nuovi spazi dei nomi di sistema, esegui di nuovo questo script per applicare le modifiche a questi spazi dei nomi.

Per annullare l'impostazione della ComputeClass predefinita per gli spazi dei nomi di sistema:

Salva il seguente script come 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."

Esegui lo script:
```
./unset-system-cc.sh
```

Configurare una ComputeClass predefinita per un cluster

Puoi impostare qualsiasi ComputeClass personalizzata come predefinita per l'intero cluster. Questa procedura prevede l'abilitazione delle ComputeClass predefinite a livello di cluster nel cluster e la creazione di una ComputeClass denominata default. Puoi persino ottenere il comportamento delle ComputeClass Autopilot integrate specificando le stesse regole di priorità in una ComputeClass denominata default.

Per utilizzare correttamente una ComputeClass predefinita nel cluster, devi eseguire entrambi i passaggi seguenti:

Per abilitare l'impostazione di una ComputeClass predefinita a livello di cluster, utilizza il --enable-default-compute-class flag quando crei o aggiorni un cluster:
- Crea un cluster:
```
gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-default-compute-class
```
  Sostituisci quanto segue:
  - CLUSTER_NAME: un nome per il cluster.
  - CONTROL_PLANE_LOCATION: la località del control plane del cluster, ad esempio us-central1.
- Aggiorna un cluster:
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-default-compute-class
```
  Sostituisci quanto segue:
  - CLUSTER_NAME: il nome del tuo cluster.
  - CONTROL_PLANE_LOCATION: la località del control plane del cluster, ad esempio us-central1.
Al termine di questo passaggio, GKE cerca una ComputeClass denominata default nel cluster. Non noterai alcuna modifica ai workload finché non configuri la ComputeClass default.
Crea una ComputeClass denominata default, come negli esempi seguenti:
- La seguente ComputeClass richiede serie di macchine specifiche:
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: default
spec:
  priorities:
  - machineFamily: n4
  - machineFamily: n2
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
  Questa ComputeClass richiede nodi che utilizzano istanze N4. Se le istanze N4 non sono disponibili, la ComputeClass richiede invece le istanze N2. Puoi configurare la default ComputeClass con uno qualsiasi dei campi disponibili in the ComputeClass CustomResourceDefinition.
- La seguente ComputeClass richiede la piattaforma di calcolo ottimizzata per container di Autopilot:
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: default
spec:
  autopilot:
    enabled: true
  priorities:
  - podFamily: general-purpose
  whenUnsatisfiable: ScaleUpAnyway
```
  Questa ComputeClass corrisponde al comportamento della ComputeClass integrata autopilot, ad eccezione del campo whenUnsatisfiable, che ha un valore ScaleUpAnyway anziché DoNotScaleUp. Questa modifica consente di evitare situazioni in cui i pod che utilizzano un selettore di nodi per hardware specifico rimangono in stato di attesa perché è stata applicata la ComputeClass predefinita a livello di cluster.
  
  La regola di priorità podFamily inserisce i pod nella piattaforma di calcolo ottimizzata per container di Autopilot. Questa regola di priorità richiede la versione GKE 1.35.2-gke.1485000 o versioni successive.
Crea la ComputeClass default nel cluster:
```
kubectl apply -f PATH_TO_MANIFEST
```
Sostituisci PATH_TO_MANIFEST con il percorso del manifest per la ComputeClass.
(Facoltativo) Se il cluster Standard ha già node pool creati manualmente che utilizzi come predefiniti per i workload per uso generico, puoi spostare questi workload per eseguirli in modalità Autopilot dopo aver impostato una ComputeClass Autopilot come predefinita a livello di cluster. Per spostare questi workload, esegui il cordon e lo svuotamento di tutti i nodi nei node pool. GKE utilizza la ComputeClass predefinita a livello di cluster per pianificare i nuovi pod in attesa.

Dopo aver impostato una ComputeClass predefinita a livello di cluster, GKE esegue la scalabilità dei node pool che soddisfano entrambi i seguenti requisiti:

La configurazione dei nodi è la stessa della configurazione della ComputeClass default.
Il pool di nodi non ha incompatibilità o etichette per una ComputeClass diversa. GKE può eseguire la scalabilità dei node pool con un'incompatibilità e un'etichetta per la ComputeClass default.

Ad esempio, se la ComputeClass default specifica la serie di macchine N4, GKE può eseguire la scalabilità di un pool di nodi esistente che utilizza istanze N4 e non ha incompatibilità o etichette per una ComputeClass diversa.

Le modifiche si applicano a tutti i nuovi pod nel cluster che non hanno già una ComputeClass. I pod esistenti potrebbero essere interessati a seconda delle impostazioni di migrazione attiva della ComputeClass predefinita a livello di cluster. Per saperne di più, consulta Migrazione attiva nelle ComputeClass predefinite.

Verificare il comportamento della ComputeClass predefinita

Per verificare se la ComputeClass predefinita che hai impostato per uno spazio dei nomi o per un cluster funziona come previsto:

Esamina il seguente deployment di esempio:

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

Questo deployment non richiede esplicitamente una ComputeClass.

Crea il 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
```
Sostituisci NAMESPACE_NAME con uno dei seguenti valori, a seconda di cosa vuoi verificare:
- Il nome di uno spazio dei nomi con una ComputeClass predefinita.
- Il nome di uno spazio dei nomi senza una ComputeClass predefinita.
GKE potrebbe impiegare un po' di tempo per creare nuovi nodi per eseguire i pod.

Identifica i nodi che eseguono i pod dal deployment di esempio:

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

L'output è simile al seguente:

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>

Recupera le etichette dei nodi:
```
kubectl get node NODE_NAME --show-labels \
    | grep "cloud.google.com/compute-class"
```
Sostituisci NODE_NAME con il nome del nodo nell'output del passaggio precedente.

L'output è simile al seguente:
```
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
```
Il valore in COMPUTECLASS_NAME è uno dei seguenti:
- ComputeClass predefinita a livello di cluster: default per i nodi creati da GKE Autopilot o dalla creazione automatica dei pool di nodi. I nodi nei node pool esistenti creati manualmente potrebbero non avere l'etichetta cloud.google.com/compute-class.
- ComputeClass predefinita a livello di spazio dei nomi: il nome della ComputeClass che hai configurato come predefinita per lo spazio dei nomi.

Disattivare la ComputeClass predefinita

Per disattivare la ComputeClass predefinita in uno spazio dei nomi o in un cluster, esegui una delle seguenti operazioni:

Per disattivare la ComputeClass predefinita a livello di spazio dei nomi per tutti i pod, rimuovi l'etichetta cloud.google.com/default-compute-class dallo spazio dei nomi:
```
kubectl label namespaces NAMESPACE_NAME \
  cloud.google.com/default-compute-class-
```
Il carattere - alla fine della chiave dell'etichetta rimuove tutte le etichette con quella chiave dall'oggetto Namespace nell'API Kubernetes.
Per disattivare la ComputeClass predefinita a livello di spazio dei nomi per i pod non DaemonSet, rimuovi l'etichetta cloud.google.com/default-compute-class-non-daemonset dallo spazio dei nomi:
```
kubectl label namespaces NAMESPACE_NAME \
  cloud.google.com/default-compute-class-non-daemonset-
```
Per disabilitare la ComputeClass predefinita a livello di cluster, utilizza il comando gcloud container clusters update con il flag --no-enable-default-compute-class:
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --no-enable-default-compute-class
```

Passaggi successivi

Scopri di più sulle ComputeClass personalizzate in GKE.