Configura buffer di capacità

Standard Autopilot

Anteprima

Questo prodotto è soggetto ai "Termini delle Offerte pre-GA" nella sezione Termini di servizio generali dei Termini specifici dei servizi. I prodotti pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni della fase di lancio.

I buffer di capacità migliorano la reattività e l'affidabilità dei workload critici gestendo in modo proattivo la capacità di riserva del cluster utilizzando una definizione di risorsa personalizzata CapacityBuffer di Kubernetes. L'utilizzo di un buffer di capacità ti consente di definire esplicitamente una quantità specifica di capacità del nodo inutilizzata all'interno del cluster. Questa capacità riservata contribuisce a garantire che GKE esegua il provisioning dei nodi in anticipo.

Quando un carico di lavoro ad alta priorità deve fare lo scale up rapidamente, il nuovo carico di lavoro può utilizzare immediatamente la capacità vuota senza attendere il provisioning dei nodi. In questo modo si riduce al minimo la latenza e si evita la contesa delle risorse durante i picchi improvvisi di domanda.

Questa pagina fornisce tre metodi per configurare i buffer di capacità: un buffer di repliche fisso, un buffer basato sulla percentuale e un buffer dei limiti di risorse.

Prima di iniziare

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

• Attiva l'API Google Kubernetes Engine.
Attiva l'API 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 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.

• Crea o accedi a un cluster GKE sulla versione 1.35.2-gke.1842000 o successive.
• (Facoltativo, ma consigliato) Abilita il provisioning automatico dei nodi sul cluster.

Crea oggetti Kubernetes prerequisiti

Per configurare un CapacityBuffer, devi disporre di uno spazio dei nomi che contenga tutti gli oggetti richiesti (il CapacityBuffer stesso e risorse aggiuntive come un PodTemplate o un workload). PodTemplate e CapacityBuffer devono trovarsi nello stesso spazio dei nomi. Puoi creare uno spazio dei nomi o utilizzarne uno esistente, incluso lo spazio dei nomi default.

A seconda del tipo di CapacityBuffer che stai configurando, devi anche disporre di uno dei seguenti elementi:

• PodTemplate: definisce i requisiti di risorse per una singola unità di capacità del buffer. La configurazione specificata nell'oggetto CapacityBuffer fa riferimento al modello di pod.

• Workload: un workload esistente a cui fai riferimento nell'oggetto CapacityBuffer. Questa guida utilizza un oggetto Deployment come esempio di workload, ma i buffer di capacità supportano uno qualsiasi dei seguenti tipi di risorse:

  • Deployment
  • ReplicaSet
  • StatefulSet
  • ReplicationController
  • Job

  • CustomResourceDefinitions (CRD) che implementano la risorsa secondaria scale.

    Nota :se utilizzi una CRD personalizzata, potresti dover concedere manualmente le autorizzazioni del gestore della scalabilità automatica del cluster per leggere la risorsa secondaria di scalabilità. Vedi Errori di autorizzazione per le risorse scalabili personalizzate.

Questa sezione fornisce esempi di questi oggetti. Se hai già un carico di lavoro che vuoi configurare con un buffer di capacità, vai ad Applicare un buffer di capacità.

Per creare un workload Kubernetes di esempio, completa i seguenti passaggi:

1. Salva il seguente manifest come namespace.yaml:

   apiVersion: v1
   kind: Namespace
   metadata:
     name: capacity-buffer-example
     labels:
       name: capacity-buffer-example
   

   Questo manifest crea uno spazio dei nomi denominato capacity-buffer-example.

2. Salva il seguente manifest come buffer-pod-template.yaml:

   apiVersion: v1
   kind: PodTemplate
   metadata:
     name: buffer-unit-template
     namespace: capacity-buffer-example # the namespace must be the same namespace as the CapacityBuffer
   template:
     spec:
       terminationGracePeriodSeconds: 0
       containers:
       - name: buffer-container
         image: registry.k8s.io/pause:3.9
         resources:
           requests:
             cpu: "1"
             memory: "1Gi"
           limits:
             cpu: "1"
             memory: "1Gi"
   

   Questo manifest crea un PodTemplate che definisce i requisiti di risorse per una singola unità di capacità del buffer (1 CPU e 1Gi memoria). Questa configurazione specifica le dimensioni delle unità di capacità che GKE esegue il provisioning per il buffer. Ad esempio, con questo PodTemplate, GKE non considera i nodi con meno di 1 CPU e 1 Gi di risorse disponibili come parte del buffer, se il cluster viene scalato.

3. Salva il seguente manifest come sample-workload-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: critical-workload-ref
     namespace: capacity-buffer-example # the namespace must be the same namespace as the CapacityBuffer
   spec:
     replicas: 10
     selector:
       matchLabels:
         app: critical-workload
     template:
       metadata:
         labels:
           app: critical-workload
       spec:
         containers:
         - name: busybox
           image: busybox
           command: ["sleep", "3600"]
           resources:
             requests:
               cpu: 100m
   

   Questo manifest crea un deployment di esempio con 10 repliche, che è l'oggetto di riferimento per l'esempio di buffer basato sulla percentuale nella sezione successiva.

4. Applica i manifest al cluster:

   kubectl apply -f namespace.yaml -f buffer-pod-template.yaml -f sample-workload-deployment.yaml
   

5. Verifica che GKE abbia creato gli oggetti:

   kubectl get podtemplate -n capacity-buffer-example
   kubectl get deployment critical-workload-ref -n capacity-buffer-example
   

   L'output è simile al seguente:

   NAME                   AGE
   buffer-unit-template   1m
   
   NAME                    READY   UP-TO-DATE   AVAILABLE   AGE
   critical-workload-ref   10/10   10           10          1m
   

Applicare un buffer di capacità

Questa sezione fornisce esempi dei diversi tipi di buffer di capacità che puoi applicare ai tuoi carichi di lavoro.

Nota: potrebbero essere necessari fino a 5 minuti prima che il buffer di capacità reagisca alle modifiche.

Configurare un buffer di repliche fisse

La configurazione di un CapacityBuffer con repliche fisse specifica il numero esatto di unità buffer che vuoi in base a un PodTemplate.

Per creare un buffer con repliche fisse, completa i seguenti passaggi:

1. Salva il seguente manifest come cb-fixed-replicas.yaml:

   apiVersion: autoscaling.x-k8s.io/v1beta1
   kind: CapacityBuffer
   metadata:
     name: fixed-replica-buffer
     namespace: NAMESPACE
   spec:
     podTemplateRef:
       name: POD_TEMPLATE
     replicas: 3
   

   Sostituisci quanto segue:

   • NAMESPACE: il nome dello spazio dei nomi, ad esempio capacity-buffer-example.
   • POD_TEMPLATE: il PodTemplate che definisce i requisiti delle risorse, ad esempio buffer-unit-template.

   Questo manifest crea una risorsa CapacityBuffer che fa riferimento a un PodTemplate per richiedere un numero specifico di unità buffer.

2. Applica il manifest:

   kubectl apply -f cb-fixed-replicas.yaml
   

3. Verifica che GKE abbia applicato il buffer di capacità:

   kubectl get capacitybuffer fixed-replica-buffer -n NAMESPACE
   

   Il campo replicas nello stato dovrebbe mostrare 3, che riflette il numero di repliche che hai definito nel manifest. Il campo STATUS dovrebbe mostrare ReadyForProvisioning.

Configurare un buffer basato sulla percentuale

La configurazione di un buffer basato sulla percentuale dimensiona dinamicamente il buffer in base a una percentuale di un carico di lavoro scalabile esistente.

Per creare un buffer basato sulla percentuale, completa i seguenti passaggi:

1. Salva il seguente manifest come cb-percentage-based.yaml:

   apiVersion: autoscaling.x-k8s.io/v1beta1
   kind: CapacityBuffer
   metadata:
     name: percentage-buffer
     namespace: NAMESPACE
   spec:
     scalableRef:
       apiGroup: apps
       kind: Deployment
       name: SCALABLE_RESOURCE_NAME
     percentage: 20
   

   Sostituisci quanto segue:

   • NAMESPACE: il nome del tuo spazio dei nomi.
   • SCALABLE_RESOURCE_NAME: il nome della risorsa scalabile, ad esempio critical-workload-ref.

   Questo manifest crea una risorsa CapacityBuffer che richiede una dimensione del buffer equivalente al 20% delle repliche della risorsa a cui viene fatto riferimento. Se utilizzi l'esempio di deployment della sezione precedente, il valore della replica è impostato su 10.

   Nota: puoi impostare il valore del campo percentage su un valore maggiore di 100 se hai bisogno di un buffer più grande delle dimensioni attuali del carico di lavoro a cui viene fatto riferimento.

2. Applica il manifest:

   kubectl apply -f cb-percentage-based.yaml
   

3. Verifica che GKE abbia applicato il buffer di capacità:

   kubectl get capacitybuffer percentage-buffer -n NAMESPACE
   

   Controlla lo stato di CapacityBuffer. Il campo replicas deve mostrare un valore dal calcolo della percentuale. Se utilizzi l'esempio di Deployment della sezione precedente, dovresti visualizzare 2 unità buffer, ovvero il 20% delle 10 repliche definite nel Deployment.

4. Testa la scalabilità dinamica eseguendo manualmente lo scale up del deployment fino a 20 repliche:

   kubectl scale deployment critical-workload-ref -n NAMESPACE --replicas=20
   

   Il controller CapacityBuffer reagisce e scala automaticamente il buffer a 4 repliche.

Configurare un buffer dei limiti delle risorse

Puoi utilizzare il campo limits per definire un numero massimo di risorse che il buffer deve consumare, calcolato in base alle dimensioni di PodTemplate.

Per creare un buffer dei limiti delle risorse, completa i seguenti passaggi:

1. Salva il seguente manifest come cb-resource-limits.yaml:

   apiVersion: autoscaling.x-k8s.io/v1beta1
   kind: CapacityBuffer
   metadata:
     name: resource-limit-buffer
     namespace: NAMESPACE
   spec:
     podTemplateRef:
       name: POD_TEMPLATE
     limits:
       cpu: "5"
       memory: "5Gi"
   

   Sostituisci quanto segue:

   • NAMESPACE: il nome dello spazio dei nomi, ad esempio capacity-buffer-example.
   • POD_TEMPLATE: il PodTemplate che definisce i requisiti delle risorse, ad esempio buffer-unit-template.

   Questo manifest crea una risorsa CapacityBuffer con un limite totale di 5 CPU e 5 GiB di memoria. Se utilizzi l'esempio PodTemplate del passaggio precedente, definisci ogni unità come 1 CPU e 1Gi memoria, il che dovrebbe generare 5 unità buffer.

2. Applica il manifest:

   kubectl apply -f cb-resource-limits.yaml
   

3. Verifica che GKE abbia applicato il buffer di capacità:

   kubectl get capacitybuffer resource-limit-buffer -n NAMESPACE
   

   Controlla lo stato di CapacityBuffer. Il campo replicas deve mostrare un valore derivato dai limiti che hai definito. Se utilizzi l'PodTemplate esempio della sezione precedente, dovresti visualizzare 5 unità buffer perché questo è il numero massimo di unità che rientrano nei limiti definiti.

Rimuovere i buffer di capacità

Se non hai più bisogno di un buffer di capacità per i tuoi carichi di lavoro, elimina l'oggetto CapacityBuffer. In questo modo vengono rimossi i pod segnaposto e il gestore della scalabilità automatica dei cluster può fare lo scale down dei nodi.

kubectl delete capacitybuffer CAPACITY_BUFFER_NAME -n NAMESPACE

Sostituisci CAPACITY_BUFFER_NAME con il nome di CapacityBuffer che vuoi eliminare.

Risoluzione dei problemi

La sezione seguente contiene informazioni sulla risoluzione dei problemi comuni relativi ai buffer di capacità.

Buffer di capacità non pronto a causa del modello di fatturazione

Se crei un CapacityBuffer per un carico di lavoro che utilizza il modello di fatturazione basato sui pod (pagamento per pod), il buffer di capacità non sarà pronto per il provisioning.

Per identificare il problema, controlla lo stato di CapacityBuffer:

kubectl describe capacitybuffer BUFFER_NAME -n NAMESPACE

Cerca una condizione di tipo ReadyForProvisioning con stato False.

Per risolvere il problema, assicurati che CapacityBuffer faccia riferimento a un workload o a PodTemplate compatibile con la fatturazione basata sui nodi.

Errori di autorizzazione per le risorse scalabili personalizzate

Se configuri un CapacityBuffer per funzionare con oggetti scalabili personalizzati (utilizzando il campo scalableRef), il gestore della scalabilità automatica del cluster potrebbe non riuscire a scalare il buffer se non dispone delle autorizzazioni necessarie.

Per risolvere il problema, concedi manualmente le autorizzazioni richieste creando un ClusterRole e un ClusterRoleBinding, come nel seguente esempio:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: custom-scale-getter
rules:
- apiGroups: ["api.example.com"]
  resources: ["customreplicatedresources/scale"]
  verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: ca-custom-scale-getter
subjects:
- kind: User
  name: "system:cluster-autoscaler"
  namespace: kube-system
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: custom-scale-getter

Per ulteriori informazioni sulla configurazione di RBAC, consulta la documentazione di Kubernetes RBAC.

Passaggi successivi

• Scopri di più sui buffer di capacità.
• Fai riferimento alla documentazione CRD CapacityBuffer.