Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Configurer des limites de ressources précises

Autopilot Standard

Pour améliorer l'efficacité de la gestion des coûts et des quotas d'infrastructure, vous pouvez définir des limites de ressources maximales pour l'autoscaler de cluster Google Kubernetes Engine (GKE). Ce document vous explique comment utiliser la ressource personnalisée CapacityQuota pour spécifier des limites de ressources d'autoscaling pour des sous-ensembles de nœuds. Contrairement aux limites de ressources à l'échelle du cluster, vous pouvez sélectionner des nœuds spécifiques dans un CapacityQuota à l'aide de sélecteurs d'étiquettes Kubernetes.

Ce document est destiné aux administrateurs de plate-forme qui gèrent le scaling et l'infrastructure des clusters. Vous devez connaître les étiquettes de nœud Kubernetes et l'autoscaler de cluster GKE.

Fonctionnement des limites de ressources CapacityQuota

Un CapacityQuota est une ressource personnalisée Kubernetes à l'échelle du cluster que vous configurez dans un fichier manifeste et appliquez au cluster. Vous utilisez les champs suivants dans la spécification CapacityQuota pour sélectionner des nœuds et spécifier des limites de ressources :

selector : filtrez des nœuds spécifiques à l'aide d'un ou de plusieurs sélecteurs d'étiquettes. Par exemple, vous pouvez sélectionner tous les nœuds d'une ComputeClass spécifique ou les nœuds qui comportent deux libellés spécifiques.
limits : spécifiez les limites de ressources maximales pour les nœuds correspondant aux sélecteurs. Par exemple, vous pouvez limiter la quantité de processeur pouvant être utilisée par une ComputeClass personnalisée spécifique ou limiter le nombre de GPU d'un type particulier.

Lorsqu'une opération de scaling à la hausse commence, l'autoscaler de cluster vérifie le nœud proposé par rapport à tous les CapacityQuotas correspondant aux libellés de nœud et par rapport à toutes les limites de ressources configurées à l'échelle du cluster. GKE ne crée le nœud que s'il ne dépasse pas les limites de ressources configurées.

Limites

GKE rejette les CapacityQuotas qui spécifient les sélecteurs d'étiquettes node.kubernetes.io/instance-type et beta.kubernetes.io/instance-type. Pour limiter les nœuds qui utilisent un type de machine spécifique, créez une ComputeClass personnalisée avec des règles de priorité machineType et sélectionnez cette ComputeClass dans votre CapacityQuota.
Comme pour les limites à l'échelle du cluster, les CapacityQuotas peuvent empêcher la migration active de ComputeClass. Étant donné que la migration active est une opération d'augmentation de la capacité, l'autoscaler de cluster vérifie le nouveau nœud potentiel par rapport à tous les CapacityQuotas applicables et aux limites de ressources à l'échelle du cluster. Si le nouveau nœud ne respecte pas l'une de ces limites, GKE ne le crée pas et la migration active n'a pas lieu. Cette situation ne se produit que si CapacityQuota est déjà égal ou proche des limites configurées.
Les limites CapacityQuota ne sont pas strictes. Dans de rares cas, vous pouvez constater que GKE dépasse légèrement les limites configurées.
Les limites CapacityQuota ne sont appliquées que par l'autoscaler de cluster. Vous pouvez dépasser les limites en augmentant la taille du cluster manuellement ou en définissant des limites inférieures à l'utilisation actuelle.
Si les nœuds du cluster dépassent les limites de CapacityQuota configurées, l'autoscaler de cluster bloque la création de nouveaux nœuds correspondant à la CapacityQuota dépassée. L'autoscaler de cluster ne réduit pas la capacité des nœuds existants qui correspondent à CapacityQuota.

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

Assurez-vous de disposer d'un cluster Autopilot ou Standard existant exécutant la version 1.36.2-gke.2064000 ou ultérieure. Pour créer un cluster, consultez la page Créer un cluster Autopilot.

Configurer des limites de ressources dans un CapacityQuota

Vous pouvez sélectionner les nœuds auxquels un CapacityQuota s'applique à l'aide de l'une des méthodes suivantes ou des deux :

Sélectionner des nœuds à l'aide de libellés de nœud exacts : spécifiez une ou plusieurs paires clé/valeur de libellé de nœud dans le champ matchLabels. GKE recherche les nœuds qui possèdent toutes les étiquettes que vous spécifiez. Cette méthode est semblable à l'utilisation du champ nodeSelector dans une spécification de pod.
Sélectionner des nœuds à l'aide d'expressions : spécifiez une ou plusieurs expressions de sélecteur d'étiquettes en indiquant la clé d'étiquette, les opérateurs et les valeurs. Cette méthode est semblable à l'utilisation du champ nodeAffinity dans une spécification de pod.

Sélectionner des nœuds à l'aide de libellés de nœuds

Pour créer un CapacityQuota basé sur la correspondance des libellés de nœuds à l'aide du champ matchLabels, procédez comme suit :

Enregistrez l'un des exemples de CapacityQuotas suivants, chacun étant destiné à un cas d'utilisation spécifique :
- Configurez les limites de ressources pour l'ensemble d'une ComputeClass personnalisée en spécifiant l'étiquette cloud.google.com/compute-class :
```
apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityQuota
metadata:
  name: capacity-quota-compute-class
spec:
  selector:
    matchLabels:
      cloud.google.com/compute-class: my-class
  limits:
    resources:
      cpu: 12
```
  Ce CapacityQuota limite l'autoscaler de cluster à un maximum de 12 processeurs sur tous les nœuds créés par GKE pour la ComputeClass my-class.
- Configurez les limites du nombre de GPU d'un type spécifique à l'aide du libellé cloud.google.com/gke-accelerator et du nom de ressource nvidia.com/gpu :
```
apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityQuota
metadata:
  name: capacity-quota-gpu
spec:
  selector:
    matchLabels:
      cloud.google.com/compute-class: my-gpu-class
      cloud.google.com/gke-accelerator: nvidia-tesla-t4
  limits:
    resources:
      nvidia.com/gpu: 16
```
  Ce CapacityQuota limite l'autoscaler de cluster à un maximum de 16 GPU NVIDIA Tesla T4 dans la ComputeClass my-gpu-class. Si vous omettez le sélecteur ComputeClass, la limite s'applique à tous les nœuds GPU NVIDIA Tesla T4 du cluster.
- Configurez des limites pour le nombre de nœuds que GKE crée dans une zone spécifique à l'aide du libellé topology.kubernetes.io/zone et du nom de ressource nodes :
```
apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityQuota
metadata:
  name: capacity-quota-zone
spec:
  selector:
    matchLabels:
      topology.kubernetes.io/zone: us-central1-b
  limits:
    resources:
      nodes: 64
```
  Cette CapacityQuota limite l'autoscaler de cluster à 64 nœuds dans la zone us-central1-b.
Créez le CapacityQuota :
```
kubectl apply -f PATH_TO_MANIFEST_FILE
```
Remplacez PATH_TO_MANIFEST_FILE par le chemin d'accès au fichier manifeste CapacityQuota que vous avez créé.

Sélectionner des nœuds à l'aide d'expressions

Pour un ciblage plus complexe, CapacityQuota permet de définir le champ matchExpressions en plus du champ matchLabels. matchExpressions permet d'utiliser des opérateurs tels que In, NotIn, Exists et DoesNotExist.

Créez un fichier manifeste CapacityQuota qui utilise le champ matchExpressions. L'exemple de CapacityQuota suivant applique des limites de processeur et de mémoire aux nœuds exécutés sur des familles de machines hautes performances spécifiques en les regroupant à l'aide de l'opérateur In :

apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityQuota
metadata:
  name: capacity-quota-high-perf-machines
spec:
  selector:
    matchExpressions:
      - key: cloud.google.com/machine-family
        operator: In
        values:
          - c2
          - c3
          - c3d
  limits:
    resources:
      cpu: 64
      memory: 128Gi

Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f PATH_TO_MANIFEST_FILE
```
Remplacez PATH_TO_MANIFEST_FILE par le chemin d'accès au fichier manifeste CapacityQuota que vous avez créé.

Vérifier la configuration de CapacityQuota

Cette section vous explique comment vérifier qu'un CapacityQuota applique activement les limites en déployant un exemple de charge de travail qui les enfreint. Pour effectuer cette vérification, procédez comme suit :

Enregistrez l'exemple de ComputeClass suivant sous le nom test-capacityquota-class.yaml :

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: test-capacityquota-class
spec:
  priorities:
  - machineFamily: n2
  nodePoolAutoCreation:
    enabled: true

Cette ComputeClass peut créer automatiquement des nœuds qui utilisent la série de machines N2.

Créez la ComputeClass :

kubectl apply -f test-capacityquota-class.yaml

Enregistrez l'exemple CapacityQuota suivant sous le nom test-capacityquota.yaml :

apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityQuota
metadata:
  name: test-capacityquota
spec:
  selector:
    matchLabels:
      cloud.google.com/compute-class: test-capacityquota-class
  limits:
    resources:
      cpu: 8

Cette CapacityQuota limite l'autoscaler à un maximum de huit ressources de processeur pour la ComputeClass test-capacityquota-class.

Créez le CapacityQuota :

kubectl apply -f test-capacityquota.yaml

Enregistrez le Déploiement suivant en tant que test-capacityquota-workload.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-capacityquota-workload
spec:
  replicas: 16
  selector:
    matchLabels:
      app: test-capacityquota-workload
  template:
    metadata:
      labels:
        app: test-capacityquota-workload
    spec:
      containers:
      - name: test
        image: gcr.io/google_containers/pause
        resources:
          limits:
            cpu: 500m
      nodeSelector:
        cloud.google.com/compute-class: test-capacityquota-class

Ce déploiement crée 16 pods, chacun demandant 500 mCPU. Étant donné que les nœuds réservent une partie du processeur pour les composants système, la somme des ressources de processeur sur tous les nœuds que GKE doit créer pour exécuter les 16 pods est supérieure à 8.

Créez le déploiement :

kubectl apply -f test-capacityquota-workload.yaml

Attendez environ deux minutes, puis vérifiez l'état de planification des pods :
```
kubectl get pods -l app=test-capacityquota-workload
```
L'autoscaler de cluster augmente le nombre de nœuds jusqu'à la limite de quota de capacité de huit processeurs. Une fois cette limite atteinte, l'autoscaler ne crée plus de nœuds. Par conséquent, certains pods du déploiement restent à l'état Pending.

Pour vérifier que CapacityQuota est à l'origine de l'état Pending, décrivez l'un des pods en attente :

kubectl describe pod PENDING_POD_NAME

Remplacez PENDING_POD_NAME par le nom d'un pod bloqué à l'état Pending.

Le résultat ressemble à ce qui suit, ce qui indique que la CapacityQuota a bloqué le scale-up du nœud :

Pod didn't trigger scale-up: 1 exceeded quota: "CapacityQuota/test-capacityquota", resources: cpu

Vous pouvez également afficher ces événements à l'aide des journaux de visibilité de l'autoscaler de cluster. Vérifiez l'événement noScaleUp, comme dans l'exemple suivant :

{
  "jsonPayload": {
    "noDecisionStatus": {
      "noScaleUp": {
        "skippedMigs": [
          {
            "reason": {
              "parameters": [
                "exceeded quota: \"CapacityQuota/test-capacityquota\", resources: cpu"
              ],
              "messageId": "no.scale.up.mig.skipped"
            },
            "mig": {
              "name": "gke-test-grp",
              "zone": "us-central1-f",
              "nodepool": "nap-n2-highcpu-2-test"
            }
          }
        ]
      }
    }
  }
}

Vérifier l'utilisation et la validité des CapacityQuotas

Le champ status de la ressource de l'API CapacityQuota fournit des informations sur l'utilisation des ressources pour les nœuds qui correspondent à CapacityQuota et sur la validité de la spécification CapacityQuota.

Pour vérifier l'état d'un CapacityQuota, exécutez la commande suivante :

kubectl describe capacityquota CAPACITY_QUOTA_NAME

Remplacez CAPACITY_QUOTA_NAME par le nom du CapacityQuota que vous souhaitez inspecter.

Dans le résultat, vérifiez les champs suivants :

Pour vérifier l'utilisation des ressources des nœuds correspondants, utilisez le champ status.used :
```
status:
  conditions:
  - lastTransitionTime: "2026-07-27T10:00:00Z"
    message: "CapacityQuota is valid"
    reason: "Valid"
    status: "True"
    type: "cluster-autoscaler.kubernetes.io/valid"
  used:
    resources:
      cpu: 32
      memory: 128Gi
```
Le champ status.used est destiné à l'observabilité et n'est pas utilisé par l'autoscaler de cluster pour appliquer des limites. Ce champ n'affiche l'utilisation qu'après une opération de scaling up réussie. L'autoscaler de cluster suit également les nœuds en attente en interne et les prend en compte dans les évaluations ultérieures du scaling à la hausse. Ce suivi interne permet d'éviter de dépasser les limites.
Pour vérifier la validité d'un CapacityQuota, utilisez le champ status.conditions :
```
status:
  conditions:
  - lastTransitionTime: "2026-07-27T10:00:00Z"
    message: "CapacityQuota is valid"
    reason: "Valid"
    status: "True"
    type: "cluster-autoscaler.kubernetes.io/valid"
  used:
    resources:
      cpu: 32
      memory: 128Gi
```
La condition cluster-autoscaler.kubernetes.io/valid vérifie si CapacityQuota utilise une configuration valide, telle qu'un sélecteur correctement formaté. Si la valeur du champ status pour cette condition est True, le CapacityQuota est valide et vos limites sont appliquées. Toutefois, si la valeur du champ status est False ou si la condition n'est pas encore présente, les limites ne sont pas appliquées. Le champ message fournit des détails sur la raison pour laquelle CapacityQuota n'est pas valide.

Étapes suivantes

En savoir plus sur le fonctionnement de l'autoscaler de cluster
Consultez la documentation de référence de l'API CapacityQuota.