Aplicar ComputeClasses a los pods de forma predeterminada

Autopilot Standard

En este documento se muestra cómo aplicar ComputeClasses de forma predeterminada a los pods de Google Kubernetes Engine (GKE) que no seleccionan explícitamente un ComputeClass. En esta página se explica cómo definir una ComputeClass como predeterminada en un espacio de nombres y en todo un clúster. Este documento está dirigido a administradores de clústeres que quieran reducir la sobrecarga manual causada por la configuración de nodos y cargas de trabajo individuales.

Ya deberías conocer las ComputeClasses personalizadas.

Acerca de las ComputeClasses predeterminadas

Puedes configurar clústeres de GKE o espacios de nombres específicos para que tengan un ComputeClass predeterminado. La clase predeterminada que configures se aplicará a cualquier pod de ese clúster o espacio de nombres que no seleccione otra ComputeClass. Cuando implementas un pod que no selecciona un ComputeClass, GKE aplica los ComputeClasses predeterminados en el siguiente orden:

1. Si el espacio de nombres tiene un ComputeClass predeterminado, GKE modifica la especificación del pod para seleccionar ese ComputeClass.
2. Si el espacio de nombres no tiene una ComputeClass predeterminada, se aplica la clase predeterminada a nivel de clúster. GKE no modifica la especificación de Pod.

Cuando defines una ComputeClass predeterminada para un clúster o un espacio de nombres, el cambio solo se aplica a los pods nuevos. Los Pods no se verán afectados hasta que se vuelvan a crear. Este comportamiento se aplica aunque tu ComputeClass tenga habilitada la migración activa.

Si tu ComputeClass predeterminado tiene el campo activeMigration.optimizeRulePriority definido como true, este ajuste puede afectar a las cargas de trabajo de tus clústeres. Para obtener más información, consulta Migración activa en ComputeClasses predeterminadas.

Antes de empezar

Antes de empezar, asegúrate de que has realizado las siguientes tareas:

• Habilita la API de Google Kubernetes Engine.
Habilitar la API de Google Kubernetes Engine
• Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la CLI de gcloud, obtén la versión más reciente ejecutando el comando gcloud components update. Es posible que las versiones anteriores de la interfaz de línea de comandos de gcloud no admitan la ejecución de los comandos de este documento.
  Nota: En las instalaciones de gcloud CLI, asegúrate de definir la compute/region propiedad. Si usas principalmente clústeres zonales, define compute/zone en su lugar. Si defines una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que tengas que especificar la ubicación en determinados comandos si la ubicación de tu clúster es diferente de la predeterminada que hayas definido.

• Tener un clúster Autopilot o Standard de GKE que ejecute una versión que admita la configuración de una ComputeClass predeterminada a nivel de clúster o de espacio de nombres. Para obtener más información, consulta la sección Requisitos.

• Si usas un clúster en modo Estándar, asegúrate de que cumples uno de los siguientes requisitos:

  • Habilita el autoescalado en al menos un grupo de nodos del clúster.
  • Si tu clúster estándar ejecuta una versión anterior a la 1.33.3-gke.1136000 y no está registrado en el canal de lanzamiento rápido, habilita el aprovisionamiento automático de nodos a nivel de clúster.

• Si quieres definir una ComputeClass personalizada como predeterminada para un espacio de nombres, implementa una ComputeClass personalizada.

Requisitos

• Para definir una ComputeClass como predeterminada a nivel de clúster, el clúster debe ejecutar la versión 1.33.1-gke.1744000 de GKE o una posterior.
• Para definir una ComputeClass como predeterminada a nivel de espacio de nombres solo para los pods que no sean DaemonSet, el clúster debe ejecutar la versión 1.33.1-gke.1788000 de GKE o una posterior.

Roles y permisos necesarios

Para obtener los permisos que necesitas para configurar ComputeClasses predeterminadas a nivel de clúster o de espacio de nombres, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos en el Google Cloud proyecto:

• Desarrollador de Kubernetes Engine (roles/container.developer)
• Actualiza el valor predeterminado de ComputeClass a nivel de clúster: Administrador de clústeres de Kubernetes Engine (roles/container.clusterAdmin)

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar acceso a proyectos, carpetas y organizaciones.

Estos roles predefinidos contienen los permisos necesarios para configurar ComputeClasses predeterminadas a nivel de clúster o de espacio de nombres. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Para configurar ComputeClasses predeterminadas a nivel de clúster o de espacio de nombres, se necesitan los siguientes permisos:

• 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
• Añadir etiquetas a espacios de nombres: container.namespaces.update
• Habilita la ComputeClass predeterminada a nivel de clúster: container.clusters.update

También puedes obtener estos permisos con roles personalizados u otros roles predefinidos.

Configurar una ComputeClass predeterminada para un espacio de nombres

Puedes anotar cualquier espacio de nombres de Kubernetes de tu clúster con el nombre de una ComputeClass para usarla como predeterminada. Si un pod implementado en ese espacio de nombres aún no ha seleccionado una ComputeClass, GKE modifica la especificación del pod para seleccionar la clase predeterminada del espacio de nombres. Puedes definir cualquier ComputeClass personalizado o integrado como predeterminado.

• Para aplicar una ComputeClass a todos los pods de un espacio de nombres de forma predeterminada, añade la etiqueta cloud.google.com/default-compute-class a ese espacio de nombres:

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

  Haz los cambios siguientes:

  • NAMESPACE_NAME: el nombre del espacio de nombres que se va a actualizar.
  • COMPUTECLASS_NAME: nombre de ComputeClass que se va a definir como predeterminado para el espacio de nombres.

  Si el comando falla y muestra el siguiente mensaje de error, significa que el espacio de nombres ya tiene un ComputeClass predeterminado:

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

  Para solucionar este error, actualice el valor predeterminado de ComputeClass del espacio de nombres.

• Para aplicar una ComputeClass a todos los pods que no sean de DaemonSet de un espacio de nombres de forma predeterminada, añade la etiqueta cloud.google.com/default-compute-class-non-daemonset a ese espacio de nombres:

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

  Si el comando falla y muestra el siguiente mensaje de error, significa que el espacio de nombres ya tiene un ComputeClass predeterminado para los pods que no son DaemonSet:

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

  Para solucionar este error, actualice el valor predeterminado de ComputeClass del espacio de nombres.

Los cambios se aplicarán a los nuevos pods de ese espacio de nombres. Los Pods que ya tengas no se verán afectados.

Actualizar la ComputeClass predeterminada de un espacio de nombres

Para sobrescribir el valor predeterminado de ComputeClass de un espacio de nombres, ejecuta uno de los siguientes comandos:

• Actualiza el valor predeterminado de ComputeClass de todos los pods del espacio de nombres:

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

  Haz los cambios siguientes:

  • NAMESPACE_NAME: el nombre del espacio de nombres que se va a actualizar.
  • COMPUTECLASS_NAME: nombre de la clase ComputeClass que se va a definir como nuevo valor predeterminado del espacio de nombres.

• Sobrescribe el valor predeterminado de ComputeClass para los pods que no sean DaemonSet en el espacio de nombres:

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

Configurar una ComputeClass predeterminada para los espacios de nombres del sistema

GKE usa espacios de nombres del sistema para ejecutar varias cargas de trabajo gestionadas, como agentes de monitorización. Algunas de estas cargas de trabajo gestionadas son DaemonSets, que deben ejecutarse en todos los nodos del clúster para proporcionar funciones críticas. Sin embargo, puedes especificar una ComputeClass predeterminada para los pods que no sean DaemonSet en los espacios de nombres del sistema, de modo que esos pods se ejecuten por separado de tus cargas de trabajo.

Para definir un ComputeClass predeterminado para los espacios de nombres del sistema, sigue estos pasos:

1. Guarda la siguiente secuencia de comandos como apply-system-cc.sh. Esta secuencia de comandos te permite aplicar una ComputeClass recomendada o una ComputeClass que ya tengas a los espacios de nombres del 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."

   Esta secuencia de comandos usa la etiqueta cloud.google.com/default-compute-class-non-daemonset, que solo afecta a los pods que no son DaemonSet en los espacios de nombres del sistema.

   Advertencia: No asignes la etiqueta cloud.google.com/default-compute-class a un espacio de nombres del sistema. Esta etiqueta afecta a los DaemonSets y puede provocar interrupciones en tu clúster.

2. Ejecuta la secuencia de comandos:

   ./apply-system-cc.sh
   

Una vez que se haya completado la secuencia de comandos, todos los nuevos pods del sistema que no sean DaemonSet usarán la ComputeClass especificada de forma predeterminada, a menos que ya tengan una. Los pods que ya estén en esos espacios de nombres no se verán afectados. Si GKE añade nuevos espacios de nombres del sistema, vuelve a ejecutar esta secuencia de comandos para aplicar los cambios a esos espacios de nombres.

Para anular la clase de cálculo predeterminada de los espacios de nombres del sistema, sigue estos pasos:

1. Guarda la siguiente secuencia de comandos como 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. Ejecuta la secuencia de comandos:

   ./unset-system-cc.sh
   

Configurar una clase de computación predeterminada para un clúster

En esta sección se muestra cómo definir una ComputeClass como predeterminada para tu clúster. En el caso de las ComputeClasses predeterminadas a nivel de clúster, no especifiques manualmente las etiquetas de nodo y las etiquetas de nodo de los grupos de nodos del clúster. GKE no escala los grupos de nodos que tienen taints de nodos para ComputeClasses. Si añades manualmente una etiqueta para default ComputeClass, GKE puede escalar ese grupo de nodos. Sin embargo, esta configuración manual no es necesaria para usar una clase de cálculo predeterminada a nivel de clúster.

Nota: En los clústeres de Autopilot, si se define un ComputeClass predeterminado para el clúster, se anula el comportamiento predeterminado de Autopilot, que coloca los pods en la plataforma de computación optimizada para contenedores.

1. Para habilitar la configuración de una ComputeClass predeterminada a nivel de clúster, ejecuta el comando gcloud container clusters update con la marca --enable-default-compute-class:

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

   Haz los cambios siguientes:

   • CLUSTER_NAME: el nombre de tu clúster.
   • CONTROL_PLANE_LOCATION: la ubicación de tu plano de control del clúster, como us-central1.

   También puedes especificar esta marca al crear un clúster de Autopilot o estándar.

2. Guarda el siguiente archivo de manifiesto, que define un ComputeClass llamado default:

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

   Este archivo de manifiesto de ejemplo solicita nodos que usen instancias N4. Si las instancias N4 no están disponibles, ComputeClass solicita instancias N2. Puedes configurar defaultComputeClass con cualquiera de los campos disponibles en la CustomResourceDefinition de ComputeClass.

3. Aplica el manifiesto a tu clúster:

   kubectl apply -f PATH_TO_MANIFEST
   

   Sustituye PATH_TO_MANIFEST por la ruta al manifiesto de ComputeClass.

Después de definir una ComputeClass predeterminada a nivel de clúster, GKE escala los grupos de nodos que cumplen los dos requisitos siguientes:

• La configuración del nodo es la misma que la de default ComputeClass.
• El grupo de nodos no tiene taints ni etiquetas para una ComputeClass diferente. GKE puede escalar grupos de nodos que tengan un taint y una etiqueta para default ComputeClass.

Por ejemplo, si default ComputeClass especifica la serie de máquinas N4, GKE puede escalar un grupo de nodos que utilice instancias N4 y que no tenga taints ni etiquetas para otra ComputeClass.

Los cambios se aplican a todos los pods nuevos del clúster que aún no tengan un ComputeClass. Es posible que los pods se vean afectados en función de los ajustes de migración activos de la ComputeClass predeterminada a nivel de clúster. Para obtener más información, consulta Migración activa en ComputeClasses predeterminadas.

Verificar el comportamiento predeterminado de ComputeClass

Para comprobar si la ComputeClass predeterminada que has definido para un espacio de nombres o un clúster funciona correctamente, haz lo siguiente:

1. Revisa el siguiente ejemplo de Deployment:

   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

   Esta implementación no solicita explícitamente un ComputeClass.

2. Crea el despliegue:

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

   Sustituye NAMESPACE_NAME por una de las siguientes opciones, en función de lo que quieras verificar:

   • Nombre de un espacio de nombres que tiene un ComputeClass predeterminado.
   • El nombre de un espacio de nombres que no tiene un ComputeClass predeterminado.

   GKE puede tardar un tiempo en crear nodos para ejecutar los pods.

3. Identifica los nodos que ejecutan los pods de la implementación de ejemplo:

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

   El resultado debería ser similar al siguiente:

   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. Obtén las etiquetas del nodo:

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

   Sustituye NODE_NAME por el nombre del nodo de la salida del paso anterior.

   El resultado debería ser similar al siguiente:

   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
   

   El valor de COMPUTECLASS_NAME es uno de los siguientes:

   • ComputeClass predeterminada a nivel de clúster: default para los nodos que se han creado con Autopilot de GKE o con la creación automática de grupos de nodos. Es posible que los nodos de los grupos de nodos creados manualmente no tengan la etiqueta cloud.google.com/compute-class.
   • ComputeClass predeterminado a nivel de espacio de nombres: el nombre de ComputeClass que has configurado como predeterminado del espacio de nombres.

Inhabilitar ComputeClass predeterminado

Para inhabilitar la ComputeClass predeterminada en un espacio de nombres o un clúster, haz una de las siguientes acciones:

• Para inhabilitar la ComputeClass predeterminada a nivel de espacio de nombres para todos los pods, quita la etiqueta cloud.google.com/default-compute-class del espacio de nombres:

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

  El carácter - al final de la clave de la etiqueta elimina todas las etiquetas con esa clave del objeto Namespace en la API de Kubernetes.

• Para inhabilitar el valor predeterminado de ComputeClass a nivel de espacio de nombres para los pods que no son DaemonSet, elimina la etiqueta cloud.google.com/default-compute-class-non-daemonset del espacio de nombres:

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

• Para inhabilitar la ComputeClass predeterminada a nivel de clúster, usa el comando gcloud container clusters update con la marca --no-enable-default-compute-class:

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

Siguientes pasos

• Consulta más información sobre las ComputeClasses personalizadas en GKE.