Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Configura limiti granulari delle risorse

Autopilot Standard

Per migliorare l'efficacia della gestione dei costi e della quota dell'infrastruttura, puoi definire i limiti massimi delle risorse per il gestore della scalabilità automatica dei cluster di Google Kubernetes Engine (GKE). Questo documento mostra come utilizzare la risorsa personalizzata CapacityQuota per specificare i limiti delle risorse di scalabilità automatica per i sottoinsiemi di nodi. A differenza dei limiti delle risorse a livello di cluster, puoi selezionare nodi specifici in un CapacityQuota utilizzando i selettori di etichette Kubernetes.

Questo documento è rivolto agli amministratori della piattaforma che gestiscono la scalabilità e l'infrastruttura dei cluster. Dovresti avere familiarità con le etichette dei nodi Kubernetes e con il gestore della scalabilità automatica dei cluster di GKE.

Come funzionano i limiti delle risorse CapacityQuota

Un CapacityQuota è una risorsa personalizzata Kubernetes con ambito cluster che configuri in un manifest e applichi al cluster. Utilizza i seguenti campi nella specifica CapacityQuota per selezionare i nodi e specificare i limiti delle risorse:

selector: filtra nodi specifici utilizzando uno o più selettori di etichette. Ad esempio, puoi selezionare tutti i nodi per una ComputeClass specifica o i nodi che hanno due etichette specifiche.
limits: specifica i limiti massimi delle risorse per i nodi che corrispondono ai selettori. Ad esempio, puoi limitare la quantità di CPU che può essere utilizzata da una specifica ComputeClass personalizzata o il numero di GPU di un tipo particolare.

Quando inizia un'operazione di scale up, il gestore della scalabilità automatica del cluster controlla il nodo proposto rispetto a tutte le CapacityQuota che corrispondono alle etichette del nodo e a tutti i limiti delle risorse a livello di cluster configurati. GKE crea il nodo solo se non viola i limiti delle risorse configurati.

Limitazioni

GKE rifiuta i CapacityQuota che specificano i selettori di etichette node.kubernetes.io/instance-type e beta.kubernetes.io/instance-type. Per limitare i nodi che utilizzano un tipo di macchina specifico, crea una ComputeClass personalizzata con regole di priorità machineType e seleziona questa ComputeClass nella quota di capacità.
Analogamente ai limiti a livello di cluster, CapacityQuotas potrebbe impedire la migrazione attiva di ComputeClass. Poiché la migrazione attiva è un'operazione di scalabilità verticale, il gestore della scalabilità automatica dei cluster controlla il potenziale nuovo nodo rispetto a tutte le CapacityQuota e ai limiti delle risorse a livello di cluster applicabili. Se il nuovo nodo viola uno di questi limiti, GKE non lo crea e la migrazione attiva non viene eseguita. Questa situazione si verifica solo se CapacityQuota ha già raggiunto o è vicino ai limiti configurati.
I limiti di CapacityQuota non sono limiti rigidi. In rari casi, potresti notare che GKE supera i limiti configurati di un piccolo margine.
I limiti CapacityQuota vengono applicati solo dal gestore della scalabilità automatica dei cluster. Puoi superare i limiti facendo lo scale up del cluster manualmente o modificando i limiti in modo che siano inferiori all'utilizzo attuale.
Se i nodi nel cluster superano i limiti di CapacityQuota configurati, il gestore della scalabilità automatica dei cluster blocca la creazione di nuovi nodi che corrispondono a CapacityQuota superato. Il gestore della scalabilità automatica del cluster non esegue fare lo scale down dei nodi esistenti che corrispondono a CapacityQuota.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti operazioni:

Abilita l'API Google Kubernetes Engine.

Abilita l'API Google Kubernetes Engine

Per 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 comando gcloud components update. 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 proprietà compute/region. 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.

Assicurati di avere un cluster Autopilot o Standard esistente che esegue la versione 1.36.2-gke.2064000 o successive. Per creare un nuovo cluster, vedi Crea un cluster Autopilot.

Configura i limiti delle risorse in un CapacityQuota

Puoi selezionare i nodi a cui si applica un CapacityQuota utilizzando uno o entrambi i seguenti metodi:

Seleziona i nodi utilizzando etichette di nodo esatte: specifica una o più coppie chiave-valore dell'etichetta di nodo nel campo matchLabels. GKE trova i nodi che hanno tutte le etichette specificate. Questo metodo è simile all'utilizzo del campo nodeSelector in una specifica del pod.
Seleziona i nodi utilizzando le espressioni: specifica una o più espressioni del selettore di etichette specificando la chiave dell'etichetta, gli operatori e i valori. Questo metodo è simile all'utilizzo del campo nodeAffinity in una specifica di pod.

Seleziona i nodi utilizzando le etichette dei nodi

Per creare un CapacityQuota basato sulla corrispondenza delle etichette dei nodi utilizzando il campo matchLabels:

Salva una delle seguenti quote di capacità di esempio, ognuna delle quali è pensata per un caso d'uso specifico:
- Configura i limiti delle risorse per un'intera ComputeClass personalizzata specificando l'etichetta 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
```
  Questo CapacityQuota limita il gestore della scalabilità automatica dei cluster a un massimo di 12 CPU in tutti i nodi creati da GKE per la classe di computing my-class.
- Configura i limiti per il numero di GPU di un tipo specifico utilizzando l'etichetta cloud.google.com/gke-accelerator e il nome della risorsa 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
```
  Questo CapacityQuota limita il gestore della scalabilità automatica dei cluster a un massimo di 16 GPU NVIDIA Tesla T4 nella ComputeClass my-gpu-class. Se ometti il selettore ComputeClass, il limite si applica a tutti i nodi GPU NVIDIA Tesla T4 nel cluster.
- Configura i limiti per il numero di nodi creati da GKE in una zona specifica utilizzando l'etichetta topology.kubernetes.io/zone e il nome della risorsa 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
```
  Questa CapacityQuota limita il gestore della scalabilità automatica del cluster a 64 nodi nella zona us-central1-b.
Crea CapacityQuota:
```
kubectl apply -f PATH_TO_MANIFEST_FILE
```
Sostituisci PATH_TO_MANIFEST_FILE con il percorso del file manifest CapacityQuota che hai creato.

Seleziona i nodi utilizzando le espressioni

Per un targeting più complesso, CapacityQuota supporta la definizione del campo matchExpressions oltre al campo matchLabels. matchExpressions consente operatori come In, NotIn, Exists e DoesNotExist.

Crea un manifest CapacityQuota che utilizza il campo matchExpressions. L'esempio CapacityQuota seguente applica limiti di CPU e memoria ai nodi in esecuzione su specifiche famiglie di macchine ad alte prestazioni raggruppandoli utilizzando l'operatore 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

Applica il manifest al tuo cluster:
```
kubectl apply -f PATH_TO_MANIFEST_FILE
```
Sostituisci PATH_TO_MANIFEST_FILE con il percorso del file manifest CapacityQuota che hai creato.

Verificare la configurazione di CapacityQuota

Questa sezione mostra come verificare che un CapacityQuota applichi attivamente i limiti eseguendo il deployment di un carico di lavoro di esempio che viola questi limiti. Per eseguire questa verifica, segui questi passaggi:

Salva il seguente esempio di ComputeClass come test-capacityquota-class.yaml:

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

Questa ComputeClass può creare automaticamente nodi che utilizzano la serie di macchine N2.

Crea la classe ComputeClass:

kubectl apply -f test-capacityquota-class.yaml

Salva il seguente esempio di CapacityQuota come 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

Questo CapacityQuota limita il gestore della scalabilità automatica a un massimo di 8 risorse CPU per la ComputeClass test-capacityquota-class.

Crea CapacityQuota:

kubectl apply -f test-capacityquota.yaml

Salva il seguente deployment come 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

Questo deployment crea 16 pod, ognuno dei quali richiede 500 mCPU. Poiché i nodi riservano parte della CPU per i componenti di sistema, la somma delle risorse CPU in tutti i nodi che GKE deve creare per eseguire i 16 pod è maggiore di 8.

Crea il deployment:

kubectl apply -f test-capacityquota-workload.yaml

Attendi circa due minuti, quindi verifica lo stato di pianificazione del pod:
```
kubectl get pods -l app=test-capacityquota-workload
```
Il gestore della scalabilità automatica dei cluster scala i nodi fino al limite di CapacityQuota di 8 CPU. Una volta raggiunto questo limite, il gestore della scalabilità automatica non crea nodi. Di conseguenza, alcuni pod nel deployment rimangono nello stato Pending.

Per verificare che CapacityQuota sia la causa dello stato Pending, descrivi uno dei pod in attesa:

kubectl describe pod PENDING_POD_NAME

Sostituisci PENDING_POD_NAME con il nome di un pod bloccato nello stato Pending.

L'output è simile al seguente, che indica che lo scale up del nodo è stato bloccato da CapacityQuota:

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

Puoi anche visualizzare questi eventi utilizzando i log di visibilità del gestore della scalabilità automatica dei cluster. Controlla l'evento noScaleUp, come nel seguente esempio:

{
  "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"
            }
          }
        ]
      }
    }
  }
}

Controlla l'utilizzo e la validità di CapacityQuotas

Il campo status nella risorsa API CapacityQuota fornisce informazioni sull'utilizzo delle risorse per i nodi che corrispondono a CapacityQuota e sulla validità della specifica CapacityQuota.

Per controllare lo stato di un CapacityQuota, esegui questo comando:

kubectl describe capacityquota CAPACITY_QUOTA_NAME

Sostituisci CAPACITY_QUOTA_NAME con il nome della risorsa CapacityQuota che vuoi ispezionare.

Nell'output, controlla i seguenti campi:

Per controllare l'utilizzo delle risorse dei nodi corrispondenti, utilizza il campo 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
```
Il campo status.used è destinato all'osservabilità e non viene utilizzato dal gestore della scalabilità automatica dei cluster per applicare i limiti. Questo campo mostra l'utilizzo solo dopo un'operazione di scalabilità verticale riuscita. Il gestore della scalabilità automatica tiene traccia anche dei nodi in attesa internamente e li prende in considerazione nelle successive valutazioni di scale up. Questo monitoraggio interno aiuta a evitare il superamento dei limiti.
Per verificare la validità di un CapacityQuota, utilizza il campo 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 condizione cluster-autoscaler.kubernetes.io/valid verifica se CapacityQuota utilizza una configurazione valida, ad esempio un selettore formattato correttamente. Se il valore nel campo status per questa condizione è True, allora CapacityQuota è valido e i limiti vengono applicati. Tuttavia, se il valore nel campo status è False o se la condizione non è ancora presente, i limiti non vengono applicati. Il campo message fornisce dettagli sul motivo per cui CapacityQuota non è valido.

Passaggi successivi

Scopri di più su come funziona il gestore della scalabilità automatica dei cluster.
Consulta il riferimento API CapacityQuota.