Agent-Sandboxes dynamisch mit HPA und Kapazitätsreserven skalieren

Auf dieser Seite wird beschrieben, wie Sie GKE Agent Sandbox Umgebungen mit dem Horizontal Pod Autoscaler (HPA) und Standby-Kapazität puffern in einem GKE Standard-Cluster dynamisch skalieren.

Standardmäßig halten Warm Pools der Agent Sandbox eine statische Anzahl von vorab bereitgestellten Replikaten bereit, um die Startlatenz von Pods zu minimieren. So lassen sich Szenarien mit variablem Traffic vermeiden, in denen die Aufrechterhaltung einer hohen Anzahl statischer Replikate hohe Rechenkosten verursachen kann.

Mit dynamischer Skalierung können Sie die Kapazitätsbereitschaft und Kosteneinsparungen ausgleichen. Bei diesem Ansatz wird die Größe von SandboxWarmPool an die Nachfrage angepasst und Standby-Kapazitätspuffer (angehaltene VMs) verwendet, um die Infrastruktur proaktiv für eine schnelle Skalierung bereitzustellen, ohne die vollen Kosten für die Überbereitstellung aktiver Knoten zu verursachen.

Hinweis

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

  • Aktivieren Sie die Google Kubernetes Engine API.
    • Google Kubernetes Engine API aktivieren
  • Wenn Sie die Google Cloud CLI für diesen Task verwenden möchten, installieren und dann initialisieren Sie die gcloud CLI. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem gcloud components update Befehl ab. Ältere gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.

Cluster erstellen

Führen Sie den folgenden Befehl aus, um einen GKE Standard-Cluster mit den erforderlichen Konfigurationen für Standby-Kapazitätspuffer und Agent Sandbox zu erstellen:

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

Ersetzen Sie Folgendes:

  • CLUSTER_NAME: Der Name des neuen Clusters.
  • VERSION: Die GKE-Version, die 1.36.0-gke.2208000 oder höher sein muss.
  • CONTROL_PLANE_LOCATION: Der Compute Engine-Standort für Ihren neuen Cluster. Wählen Sie für regionale Cluster eine Region (z. B. us-central1) oder für zonale Cluster eine Zone (z. B. us-central1-a) aus.
  • MAX_CPU: Maximale CPU-Limits für die automatische Bereitstellung, z. B. 4000.
  • MAX_MEMORY: Maximale Speicherlimits für die automatische Bereitstellung in GB, z. B. 12000.
  • PROJECT_ID: Ihre Google Cloud Projekt-ID.

Agent Sandbox-Komponenten konfigurieren

Sie müssen ein SandboxTemplate und einen SandboxWarmPool definieren, um Ihre Sandbox-Arbeitslasten zu verwalten.

  1. Speichern Sie das folgende Manifest als 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"

    Ersetzen Sie NAMESPACE durch Ihren Namespace, z. B. agent-sandbox-demo.

  2. Wenden Sie das Manifest an:

    kubectl apply -f sandboxtemplate.yaml

  3. Speichern Sie das folgende Manifest als sandboxwarmpool.yaml. Dadurch wird ein anfänglicher statischer Pool von Replikaten eingerichtet.

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

  4. Wenden Sie das Manifest an:

    kubectl apply -f sandboxwarmpool.yaml

Messwerterfassung konfigurieren

Der Agent Sandbox-Controller stellt einen Zählermesswert für die Anzahl der beanspruchten Sandboxes bereit: agent_sandbox_claim_creation_total. Sie können eine PodMonitoring-Ressource konfigurieren, um diesen Messwert zu erfassen und an Google Cloud Managed Service for Prometheus zu senden.

  1. Speichern Sie das folgende Manifest als 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. Wenden Sie das Manifest an:

    kubectl apply -f podmonitoring.yaml

Adapter für benutzerdefinierte Messwerte aktivieren

Damit der HPA Messwerte aus Google Cloud Managed Service for Prometheus lesen kann, müssen Sie den custom-metrics-stackdriver-adapter bereitstellen.

Aktivieren Sie die erforderlichen IAM-Bindungen. Führen Sie folgende Befehle aus:

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

Ersetzen Sie PROJECT_NUMBER durch Ihre Google Cloud Projektnummer.

RBAC-Berechtigungen für SandboxWarmPool konfigurieren

Der Controller für Kapazitätspuffer benötigt die Berechtigung zum Lesen der Skalierungsunterressource der benutzerdefinierten Ressource SandboxWarmPool.

  1. Speichern Sie das folgende Manifest als 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. Wenden Sie das Manifest an:

    kubectl apply -f capacity-buffer-rbac.yaml

Kapazitätspuffer konfigurieren

Konfigurieren Sie einen CapacityBuffer, um einen Infrastrukturpuffer beizubehalten, der proportional zur Größe des SandboxWarmPool ist. Weitere Informationen finden Sie unter Kapazitätspuffer konfigurieren.

  1. Speichern Sie das folgende Manifest als capacitybuffer.yaml: In diesem Beispiel wird ein Puffer beibehalten, der 200% der Replikate des SandboxWarmPool entspricht, indem Standby-Kapazität (angehaltene VMs) verwendet wird.

    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. Wenden Sie das Manifest an:

    kubectl apply -f capacitybuffer.yaml

Horizontales Pod-Autoscaling konfigurieren

Verbinden Sie den SandboxWarmPool mit dem HPA, um Replikate dynamisch auf Grundlage des benutzerdefinierten Messwerts zu skalieren.

  1. Speichern Sie das folgende Manifest als 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. Wenden Sie das Manifest an:

    kubectl apply -f hpa.yaml

Skalierungsereignisse beobachten

Sie können HPA- und Kapazitätspufferereignisse beobachten, um die dynamische Skalierung zu überprüfen.

HPA-Ereignisse beobachten

Führen Sie den folgenden Befehl aus, um HPA-Ereignisse zu beobachten:

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

Die Beispielausgabe bei der Skalierung sieht dann ungefähr so aus:

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

CapacityBuffer-Ereignisse beobachten

Führen Sie den folgenden Befehl aus, um CapacityBuffer-Ereignisse zu beobachten:

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

Die Beispielausgabe, die die Wiederaufnahme oder Aufskalierung angehaltener VMs zeigt, sieht dann ungefähr so aus:

TriggeredScaleUp capacity buffer 20 fake pods triggered scale-up

Nächste Schritte