Scalare dinamicamente le sandbox degli agenti utilizzando HPA e i buffer di capacità

Questa pagina spiega come scalare dinamicamente gli ambienti GKE Agent Sandbox utilizzando Horizontal Pod Autoscaler (HPA) e i buffer di capacità di riserva su un cluster GKE Standard.

Per impostazione predefinita, i pool in caldo di Agent Sandbox mantengono un numero statico di repliche pre-provisioning pronte per ridurre al minimo la latenza di avvio dei pod. In questo modo, puoi evitare scenari con traffico variabile, in cui il mantenimento di un numero elevato di repliche statiche può comportare costi di calcolo elevati.

Puoi bilanciare la preparazione della capacità e il risparmio sui costi utilizzando la scalabilità dinamica. Questo approccio regola le dimensioni di SandboxWarmPool in base alla domanda e utilizza buffer di capacità di riserva (VM sospese) per eseguire il provisioning proattivo dell'infrastruttura per una scalabilità rapida senza il costo totale del provisioning eccessivo dei nodi attivi.

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.

Crea un cluster

Per creare un cluster GKE Standard con le configurazioni richieste per i buffer di capacità di riserva e la sandbox dell'agente, esegui questo comando:

gcloud container clusters create CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION \
    --cluster-version=VERSION \
    --enable-autoscaling \
    --enable-autoprovisioning \
    --max-cpu=MAX_CPU \
    --max-memory=MAX_MEMORY \
    --enable-agent-sandbox \
    --enable-image-streaming \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --monitoring=SYSTEM

Sostituisci quanto segue:

  • CLUSTER_NAME: il nome del nuovo cluster.
  • VERSION: la versione di GKE, che deve essere 1.36.0-gke.2208000 o successiva.
  • CONTROL_PLANE_LOCATION: la località di Compute Engine per il nuovo cluster. Scegli una regione per i cluster regionali (ad esempio us-central1) o una zona per i cluster zonali (ad esempio us-central1-a).
  • MAX_CPU: limiti massimi di CPU per il provisioning automatico, ad esempio 4000.
  • MAX_MEMORY: limiti massimi di memoria per il provisioning automatico in GB, ad esempio 12000.
  • PROJECT_ID: il tuo ID progetto Google Cloud .

Configurare i componenti di Agent Sandbox

Devi definire un SandboxTemplate e un SandboxWarmPool per gestire i tuoi workload in sandbox.

  1. Salva il seguente manifest come sandboxtemplate.yaml:

    apiVersion: extensions.agents.x-k8s.io/v1alpha1
kind: SandboxTemplate
metadata:
  name: agent-template
  namespace: NAMESPACE
spec:
  podTemplate:
    metadata:
      labels:
        app: agent-sandbox-workload
    spec:
      restartPolicy: Never
      containers:
        - name: python-agent
          image: python:3.11-slim
          command: ["/bin/sh", "-c"]
          args: ["echo 'Hello from the Sandbox!' && sleep 3600"]
          resources:
            requests:
              cpu: "1000m"
              memory: "100Mi"

    Sostituisci NAMESPACE con il tuo spazio dei nomi, ad esempio agent-sandbox-demo.

  2. Applica il manifest:

    kubectl apply -f sandboxtemplate.yaml

  3. Salva il seguente manifest come sandboxwarmpool.yaml. In questo modo viene creato un pool statico iniziale di repliche.

    apiVersion: extensions.agents.x-k8s.io/v1alpha1
kind: SandboxWarmPool
metadata:
  name: agent-warmpool
  namespace: NAMESPACE
spec:
  replicas: 10
  sandboxTemplateRef:
    name: agent-template

  4. Applica il manifest:

    kubectl apply -f sandboxwarmpool.yaml

Configurazione della raccolta di metriche

Il controller Agent Sandbox espone una metrica del contatore per il numero di sandbox rivendicate: agent_sandbox_claim_creation_total. Puoi configurare una risorsa PodMonitoring per raccogliere questa metrica e inviarla a Google Cloud Managed Service per Prometheus.

  1. Salva il seguente manifest come podmonitoring.yaml:

    apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: agent-sandbox-controller-monitoring
  namespace: agent-sandbox-system # Namespace where the controller is running
spec:
  selector:
    matchLabels:
      app: agent-sandbox-controller
  endpoints:
  - port: 8080 # Port where metrics are exposed
    path: /metrics
    interval: 15s

  2. Applica il manifest:

    kubectl apply -f podmonitoring.yaml

Attivare l'adattatore delle metriche personalizzate

Per consentire a HPA di leggere le metriche da Google Cloud Managed Service per Prometheus, devi eseguire il deployment di custom-metrics-stackdriver-adapter.

Abilita i binding IAM richiesti. Esegui questi comandi:

kubectl create clusterrolebinding cluster-admin-binding \
    --clusterrole=cluster-admin --user="$(gcloud config get-value account)"

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

gcloud projects add-iam-policy-binding PROJECT_ID \
  --role=roles/monitoring.viewer \
  --member=principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/custom-metrics/sa/custom-metrics-stackdriver-adapter

Sostituisci PROJECT_NUMBER con il numero del tuo progetto Google Cloud .

Configurare le autorizzazioni RBAC per SandboxWarmPool

Il controller del buffer di capacità deve disporre dell'autorizzazione di lettura della risorsa secondaria di scalabilità della risorsa personalizzata SandboxWarmPool.

  1. Salva il seguente manifest come capacity-buffer-rbac.yaml:

    apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: sandbox-warmpool-scale-reader
rules:
- apiGroups: ["extensions.agents.x-k8s.io"]
  resources: ["sandboxwarmpools/scale"]
  verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: ca-sandbox-warmpool-scale-reader
subjects:
- kind: User
  name: "system:cluster-autoscaler"
  namespace: kube-system
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: sandbox-warmpool-scale-reader

  2. Applica il manifest:

    kubectl apply -f capacity-buffer-rbac.yaml

Configura buffer di capacità

Configura un CapacityBuffer per mantenere un buffer dell'infrastruttura proporzionale alle dimensioni di SandboxWarmPool. Per saperne di più, consulta Configura i buffer di capacità.

  1. Salva il seguente manifest come capacitybuffer.yaml. Questo esempio mantiene un buffer equivalente al 200% delle repliche di SandboxWarmPool utilizzando la capacità di standby (VM sospese).

    apiVersion: autoscaling.x-k8s.io/v1beta1
kind: CapacityBuffer
metadata:
  name: agent-warmpool-buffer
  namespace: NAMESPACE
spec:
  percentage: 200
  scalableRef:
    apiGroup: extensions.agents.x-k8s.io
    kind: SandboxWarmPool
    name: agent-warmpool
  provisioningStrategy: "buffer.gke.io/standby-capacity"

  2. Applica il manifest:

    kubectl apply -f capacitybuffer.yaml

Configura Horizontal Pod Autoscaler

Collega SandboxWarmPool all'HPA per scalare dinamicamente le repliche in base alla metrica personalizzata.

  1. Salva il seguente manifest come hpa.yaml:

    apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: agent-warmpool-hpa
  namespace: NAMESPACE
spec:
  scaleTargetRef:
    apiVersion: extensions.agents.x-k8s.io/v1alpha1
    kind: SandboxWarmPool
    name: agent-warmpool
  minReplicas: 10
  maxReplicas: 100
  metrics:
  - type: External
    external:
      metric:
        name: "prometheus.googleapis.com|agent_sandbox_claim_creation_total|counter"
        selector:
          matchLabels:
            metric.labels.warmpool_name: "agent-warmpool"
      target:
        type: Value
        value: 0.2

  2. Applica il manifest:

    kubectl apply -f hpa.yaml

Monitorare gli eventi di scalabilità

Puoi monitorare gli eventi HPA e del buffer di capacità per verificare lo scaling dinamico.

Monitorare gli eventi HPA

Per monitorare gli eventi HPA, esegui questo comando:

kubectl get events -n NAMESPACE --watch \
    --field-selector involvedObject.kind=HorizontalPodAutoscaler

L'output di esempio quando si verifica lo scaling è simile al seguente:

SuccessfulRescale New size: 20; reason: external metric prometheus.googleapis.com|agent_sandbox_claim_creation_total|counter above target

Monitorare gli eventi CapacityBuffer

Per monitorare gli eventi del buffer di capacità, esegui questo comando:

kubectl get events -n NAMESPACE --watch \
    --field-selector involvedObject.kind=CapacityBuffer

L'output di esempio che mostra la ripresa o lo scale up della VM sospesa è simile al seguente:

TriggeredScaleUp capacity buffer 20 fake pods triggered scale-up

Passaggi successivi