Cette page a été traduite par l'API Cloud Translation.

Appliquer des ComputeClasses aux pods par défaut

Ce document explique comment appliquer des ComputeClasses par défaut aux pods Google Kubernetes Engine (GKE) qui ne sélectionnent pas explicitement de ComputeClass. Cette page explique comment définir une ComputeClass par défaut dans un espace de noms et pour un cluster entier. Ce document s'adresse aux administrateurs de clusters qui souhaitent réduire les frais généraux manuels causés par la configuration individuelle des charges de travail et des nœuds.

Vous devez déjà connaître les ComputeClasses personnalisées.

À propos des ComputeClasses par défaut

Vous pouvez configurer des clusters GKE ou des espaces de noms spécifiques pour qu'ils disposent d'une ComputeClass par défaut. La classe par défaut que vous configurez s'applique à tous les pods de ce cluster ou de cet espace de noms qui ne sélectionnent pas une autre ComputeClass. Lorsque vous déployez un pod qui ne sélectionne pas de ComputeClass, GKE applique les ComputeClass par défaut dans l'ordre suivant :

Si l'espace de noms possède une ComputeClass par défaut, GKE modifie la spécification du pod pour sélectionner cette ComputeClass.
Si l'espace de noms ne possède pas de ComputeClass par défaut, la classe par défaut au niveau du cluster s'applique. GKE ne modifie pas la spécification du pod.

Lorsque vous définissez une ComputeClass par défaut pour un cluster ou un espace de noms, votre modification ne s'applique qu'aux nouveaux pods. Les pods existants ne sont pas affectés tant qu'ils ne sont pas recréés. Ce comportement s'applique même si la migration active est activée pour votre ComputeClass.

Si le champ activeMigration.optimizeRulePriority de votre ComputeClass par défaut est défini sur true, ce paramètre peut affecter les charges de travail de vos clusters. Pour en savoir plus, consultez Migration active dans les ComputeClasses par défaut.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Activez l'API Google Kubernetes Engine.

Activer l'API Google Kubernetes Engine

Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez la gcloud CLI. Si vous avez déjà installé la gcloud CLI, obtenez la dernière version en exécutant la commande gcloud components update. Il est possible que les versions antérieures de la gcloud CLI ne permettent pas d'exécuter les commandes de ce document.
Remarque : Pour les installations de la gcloud CLI existantes, veillez à définir la propriété compute/region. Si vous utilisez principalement des clusters zonaux, définissez plutôt compute/zone. En définissant un emplacement par défaut, vous pouvez éviter les erreurs gcloud CLI de ce type : One of [--zone, --region] must be supplied: Please specify location. Vous devrez peut-être spécifier l'emplacement dans certaines commandes si celui de votre cluster diffère de l'emplacement par défaut que vous avez défini.

Disposer d'un cluster GKE Autopilot ou Standard qui exécute une version permettant de définir une ComputeClass par défaut au niveau du cluster ou de l'espace de noms. Pour en savoir plus, consultez la section Exigences.
Si vous utilisez un cluster en mode standard, assurez-vous de remplir l'une des conditions suivantes :
- Activez l'autoscaling sur au moins un pool de nœuds du cluster.
- Si votre cluster Standard exécute une version antérieure à 1.33.3-gke.1136000 et n'est pas enregistré dans le canal de publication rapide, activez le provisionnement automatique des nœuds au niveau du cluster.
Si vous souhaitez définir une ComputeClass personnalisée comme classe par défaut pour un espace de noms, déployez une ComputeClass personnalisée.

Conditions requises

Pour définir une ComputeClass comme valeur par défaut au niveau du cluster, celui-ci doit exécuter GKE version 1.33.1-gke.1744000 ou ultérieure.
Pour définir une ComputeClass comme valeur par défaut au niveau de l'espace de noms uniquement pour les pods non DaemonSet, le cluster doit exécuter GKE version 1.33.1-gke.1788000 ou ultérieure.

Rôles et autorisations nécessaires

Pour obtenir les autorisations nécessaires pour configurer des ComputeClasses par défaut au niveau du cluster ou de l'espace de noms, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet Google Cloud :

Développeur Kubernetes Engine (roles/container.developer)
Mettez à jour la ComputeClass par défaut au niveau du cluster : Administrateur de cluster Kubernetes Engine (roles/container.clusterAdmin)

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ces rôles prédéfinis contiennent les autorisations requises pour configurer les ComputeClasses par défaut au niveau du cluster ou de l'espace de noms. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Vous devez disposer des autorisations suivantes pour configurer les ComputeClasses par défaut au niveau du cluster ou de l'espace de noms :

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
Ajoutez des libellés aux espaces de noms : container.namespaces.update
Activez la ComputeClass par défaut au niveau du cluster : container.clusters.update

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Configurer une ComputeClass par défaut pour un espace de noms

Vous pouvez annoter n'importe quel espace de noms Kubernetes de votre cluster avec le nom d'une ComputeClass à utiliser par défaut. Si un pod déployé dans cet espace de noms ne sélectionne pas déjà une ComputeClass, GKE modifie la spécification du pod pour sélectionner la classe par défaut dans l'espace de noms. Vous pouvez définir n'importe quelle ComputeClass personnalisée ou intégrée comme classe par défaut.

Pour appliquer une ComputeClass à tous les pods d'un espace de noms par défaut, ajoutez le libellé cloud.google.com/default-compute-class à cet espace de noms :
```
kubectl label namespaces NAMESPACE_NAME \
    cloud.google.com/default-compute-class=COMPUTECLASS_NAME
```
Remplacez les éléments suivants :
- NAMESPACE_NAME : nom de l'espace de noms à mettre à jour.
- COMPUTECLASS_NAME : nom de la ComputeClass à définir comme valeur par défaut pour l'espace de noms.
Si la commande échoue avec le message d'erreur suivant, l'espace de noms dispose déjà d'une ComputeClass par défaut :
```
error: 'cloud.google.com/default-compute-class' already has a value, and --overwrite is false
```
Pour résoudre cette erreur, mettez à jour la ComputeClass par défaut pour l'espace de noms.
Pour appliquer une ComputeClass à tous les pods non DaemonSet d'un espace de noms par défaut, ajoutez le libellé cloud.google.com/default-compute-class-non-daemonset à cet espace de noms :
```
kubectl label namespaces NAMESPACE_NAME \
    cloud.google.com/default-compute-class-non-daemonset=COMPUTECLASS_NAME
```
Si la commande échoue et affiche le message d'erreur suivant, cela signifie que l'espace de noms dispose déjà d'une ComputeClass par défaut pour les pods non DaemonSet :
```
error: 'cloud.google.com/default-compute-class-non-daemonset' already has a value, and --overwrite is false
```
Pour résoudre cette erreur, mettez à jour la ComputeClass par défaut pour l'espace de noms.

Vos modifications s'appliquent à tous les nouveaux pods de cet espace de noms. Les pods existants ne sont pas affectés.

Mettre à jour la classe ComputeClass par défaut existante dans un espace de noms

Pour remplacer la ComputeClass par défaut existante pour un espace de noms, exécutez l'une des commandes suivantes :

Mettez à jour la ComputeClass par défaut pour tous les pods de l'espace de noms :
```
kubectl label namespaces NAMESPACE_NAME   \
    cloud.google.com/default-compute-class=COMPUTECLASS_NAME \
    --overwrite
```
Remplacez les éléments suivants :
- NAMESPACE_NAME : nom de l'espace de noms à mettre à jour.
- COMPUTECLASS_NAME : nom de la ComputeClass à définir comme nouvelle valeur par défaut pour l'espace de noms.

Remplacez la ComputeClass par défaut pour les pods non DaemonSet dans l'espace de noms :

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

Configurer une ComputeClass par défaut pour les espaces de noms système

GKE utilise des espaces de noms système pour exécuter diverses charges de travail gérées, telles que des agents de surveillance. Certaines de ces charges de travail gérées sont des DaemonSets, qui doivent s'exécuter sur chaque nœud du cluster pour fournir des fonctionnalités critiques. Toutefois, vous pouvez spécifier une ComputeClass par défaut pour les pods non DaemonSet dans les espaces de noms système, afin que ces pods s'exécutent séparément de vos charges de travail.

Pour définir une ComputeClass par défaut pour les espaces de noms système, procédez comme suit :

Enregistrez le script suivant sous le nom apply-system-cc.sh. Ce script vous permet d'appliquer une ComputeClass recommandée ou votre propre ComputeClass existante aux espaces de noms système.

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

Ce script utilise le libellé cloud.google.com/default-compute-class-non-daemonset, qui n'affecte que les pods non DaemonSet dans les espaces de noms système.

Exécutez le script :
```
./apply-system-cc.sh
```

Une fois le script terminé, tous les nouveaux pods système non DaemonSet utilisent la ComputeClass spécifiée par défaut, sauf s'ils en ont déjà une. Les pods existants dans ces espaces de noms ne sont pas affectés. Si GKE ajoute de nouveaux espaces de noms système, exécutez à nouveau ce script pour appliquer les modifications à ces espaces de noms.

Pour annuler la définition de la ComputeClass par défaut pour les espaces de noms système, procédez comme suit :

Enregistrez le script suivant sous le nom 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."

Exécutez le script :
```
./unset-system-cc.sh
```

Configurer une classe de calcul par défaut pour un cluster

Cette section vous explique comment définir une ComputeClass par défaut pour votre cluster. Pour les ComputeClasses par défaut au niveau du cluster, ne spécifiez pas manuellement les rejets de nœuds ni les étiquettes de nœuds pour les pools de nœuds existants dans le cluster. GKE ne met pas à l'échelle les pools de nœuds qui présentent des rejets de nœuds pour les ComputeClasses. Si vous ajoutez manuellement un libellé pour la ComputeClass default, GKE peut mettre à l'échelle ce pool de nœuds. Toutefois, cette configuration manuelle n'est pas nécessaire pour utiliser une classe de calcul par défaut au niveau du cluster.

Pour activer la définition d'une ComputeClass par défaut au niveau du cluster, exécutez la commande gcloud container clusters update avec l'indicateur --enable-default-compute-class :
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --enable-default-compute-class
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster
- CONTROL_PLANE_LOCATION : emplacement du plan de contrôle de votre cluster, par exemple us-central1.
Vous pouvez également spécifier cet indicateur lorsque vous créez un cluster Autopilot ou Standard.
Enregistrez le fichier manifeste suivant, qui définit un ComputeClass nommé default :
```
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: default
spec:
  priorities:
  - machineFamily: n4
  - machineFamily: n2
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true
```
Cet exemple de fichier manifeste demande des nœuds qui utilisent des instances N4. Si les instances N4 ne sont pas disponibles, les requêtes ComputeClass demandent des instances N2 à la place. Vous pouvez configurer la default ComputeClass avec l'un des champs disponibles dans la définition de ressource personnalisée ComputeClass.
Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f PATH_TO_MANIFEST
```
Remplacez PATH_TO_MANIFEST par le chemin d'accès au fichier manifeste de ComputeClass.

Une fois que vous avez défini une ComputeClass par défaut au niveau du cluster, GKE met à l'échelle les pools de nœuds qui répondent aux deux exigences suivantes :

La configuration des nœuds est identique à celle de la ComputeClass default.
Le pool de nœuds ne comporte aucun rejet ni aucune étiquette pour une autre ComputeClass. GKE peut mettre à l'échelle les pools de nœuds qui comportent un rejet et une étiquette pour la classe de calcul default.

Par exemple, si la classe de calcul default spécifie la série de machines N4, GKE peut mettre à l'échelle un pool de nœuds existant qui utilise des instances N4 et ne comporte pas de taints ni de libellés pour une autre classe de calcul.

Vos modifications s'appliquent à tous les nouveaux pods du cluster qui n'ont pas encore de ComputeClass. Les pods existants peuvent être affectés en fonction des paramètres de migration actifs de la ComputeClass par défaut au niveau du cluster. Pour en savoir plus, consultez Migration active dans les ComputeClasses par défaut.

Vérifier le comportement par défaut de ComputeClass

Pour vérifier que la ComputeClass par défaut que vous avez définie pour un espace de noms ou pour un cluster fonctionne comme prévu, procédez comme suit :

Consultez l'exemple de déploiement suivant :

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

Ce déploiement ne demande pas explicitement de ComputeClass.

Créez le déploiement :
```
kubectl apply --namespace=NAMESPACE_NAME \
    -f https://raw.githubusercontent.com/GoogleCloudPlatform/kubernetes-engine-samples/refs/heads/main/quickstarts/hello-app/manifests/helloweb-deployment.yaml
```
Remplacez NAMESPACE_NAME par l'un des éléments suivants, selon ce que vous souhaitez vérifier :
- Nom d'un espace de noms qui possède une ComputeClass par défaut.
- Nom d'un espace de noms qui ne possède pas de ComputeClass par défaut.
La création de nœuds pour exécuter les pods peut prendre un certain temps.

Identifiez les nœuds qui exécutent les pods à partir de l'exemple de déploiement :

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

Le résultat ressemble à ce qui suit :

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>

Obtenez les libellés de nœuds :
```
kubectl get node NODE_NAME --show-labels \
    | grep "cloud.google.com/compute-class"
```
Remplacez NODE_NAME par le nom du nœud obtenu à l'étape précédente.

Le résultat ressemble à ce qui suit :
```
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
```
La valeur de COMPUTECLASS_NAME est l'une des suivantes :
- ComputeClass par défaut au niveau du cluster : default pour les nœuds créés par GKE Autopilot ou par la création automatique de pools de nœuds. Il est possible que les nœuds des pools de nœuds existants créés manuellement ne comportent pas le libellé cloud.google.com/compute-class.
- ComputeClass par défaut au niveau de l'espace de noms : nom de la ComputeClass que vous avez configurée comme valeur par défaut de l'espace de noms.

Désactiver la ComputeClass par défaut

Pour désactiver la ComputeClass par défaut dans un espace de noms ou un cluster, procédez de l'une des manières suivantes :

Pour désactiver la ComputeClass par défaut au niveau de l'espace de noms pour tous les pods, supprimez l'étiquette cloud.google.com/default-compute-class de l'espace de noms :
```
kubectl label namespaces NAMESPACE_NAME \
  cloud.google.com/default-compute-class-
```
Le caractère - à la fin de la clé du libellé supprime tous les libellés associés à cette clé de l'objet Namespace dans l'API Kubernetes.
Pour désactiver la ComputeClass par défaut au niveau de l'espace de noms pour les pods non DaemonSet, supprimez l'étiquette cloud.google.com/default-compute-class-non-daemonset de l'espace de noms :
```
kubectl label namespaces NAMESPACE_NAME \
  cloud.google.com/default-compute-class-non-daemonset-
```
Pour désactiver la ComputeClass par défaut au niveau du cluster, utilisez la commande gcloud container clusters update avec l'option --no-enable-default-compute-class :
```
gcloud container clusters update CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --no-enable-default-compute-class
```

Étapes suivantes

En savoir plus sur les ComputeClasses personnalisées dans GKE