Alcune o tutte le informazioni in questa pagina potrebbero non essere applicabili a Cloud de Confiance di S3NS. Per maggiori dettagli, consulta Differenze rispetto a Google Cloud.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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

Standard

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

Per impostazione predefinita, i pool attivi di Agent Sandbox mantengono un numero statico di repliche di cui è stato eseguito il provisioning per ridurre al minimo la latenza di avvio dei pod. In questo modo è possibile 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 i buffer di capacità in standby (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 attività:

Abilita l'API Google Kubernetes Engine.

Abilita l'API Google 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 gcloud components update comando. 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 compute/region proprietà. 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.

Un cluster GKE Standard che esegue la versione 1.36.0-gke.2208000 o successive.

Nota: i buffer in standby richiedono GKE versione 1.36.0-gke.2253000 o successive.
Abilita l'add-on Agent Sandbox sul cluster.

Crea un cluster

Per creare un cluster GKE Standard con le configurazioni richieste per i buffer di capacità in standby e Agent Sandbox, esegui il seguente 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.s3ns.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 successive.
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: l'ID del tuo Cloud de Confiance progetto.

Configura i componenti di Agent Sandbox

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

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.

Applica il manifest:
```
kubectl apply -f sandboxtemplate.yaml
```

Salva il seguente manifest come sandboxwarmpool.yaml. In questo modo viene stabilito 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

Applica il manifest:
```
kubectl apply -f sandboxwarmpool.yaml
```

Configurazione della raccolta di metriche

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

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

Applica il manifest:
```
kubectl apply -f podmonitoring.yaml
```

Abilita 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.s3ns.svc.id.goog/subject/ns/custom-metrics/sa/custom-metrics-stackdriver-adapter

Sostituisci PROJECT_NUMBER con il numero del tuo Cloud de Confiance progetto.

Configura le autorizzazioni RBAC per SandboxWarmPool

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

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

Applica il manifest:

kubectl apply -f capacity-buffer-rbac.yaml

Configura il buffer di capacità

Configura un CapacityBuffer per mantenere un buffer di infrastruttura proporzionale alle dimensioni di SandboxWarmPool. Per ulteriori informazioni, consulta Configurare i buffer di capacità.

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

Nota: i buffer di capacità basati sulla percentuale vengono arrotondati per difetto. Per le dimensioni di deployment ridotte, questo potrebbe comportare un valore del buffer pari a zero.
```
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"
```
Applica il manifest:
```
kubectl apply -f capacitybuffer.yaml
```

Configura Horizontal Pod Autoscaler

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

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

Applica il manifest:
```
kubectl apply -f hpa.yaml
```

Monitora gli eventi di scalabilità

Puoi monitorare gli eventi HPA e del buffer di capacità per verificare la scalabilità dinamica.

Monitora gli eventi HPA

Per monitorare gli eventi HPA, esegui il seguente comando:

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

L'output di esempio quando si verifica la scalabilità è simile al seguente:

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

Monitora gli eventi CapacityBuffer

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

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

L'output di esempio che mostra la ripresa o lo scale-up delle VM sospese è simile al seguente:

TriggeredScaleUp capacity buffer 20 fake pods triggered scale-up

Passaggi successivi

Scopri di più su Agent Sandbox.
Scopri di più sui buffer di capacità.
Scopri come utilizzare Kata Containers open source con Agent Sandbox. Kata Containers non è un Cloud de Confiance prodotto. Se installi e utilizzi questo software, la gestione e la risoluzione dei problemi sono di tua responsabilità. L'assistenza e gli SLA di Google non si applicano a Kata Containers.