Agent Sandbox in der GKE installieren

In diesem Dokument wird erläutert, wie Sie den Open-Source-Controller Agent Sandbox in einem GKE-Cluster (Google Kubernetes Engine) installieren, um isolierte Agent-Arbeitslasten in dedizierten Kubernetes-Pods auszuführen. Außerdem erfahren Sie, wie Sie eine Sandbox-Ressource erstellen, die nicht vertrauenswürdigen Code in der gVisor-Laufzeit ausführt. Für die meisten Agent-Arbeitslasten sollten Sie stattdessen Agent Substrate in GKE verwenden, da damit mehr Agenten auf denselben Knoten ausgeführt werden können. Verwenden Sie die Agent Sandbox in GKE, wenn jeder Agent einen dedizierten Pod, GPUs oder TPUs, eine vollständige Kubernetes-PodSpec oder einen GKE Autopilot-Cluster benötigt. Informationen zum Vergleichen von Agent Sandbox in GKE mit Agent Substrate in GKE und zum Auswählen einer Architektur für Ihre KI-Agent-Arbeitslasten finden Sie unter Architektur für KI-Agent-Arbeitslasten in GKE planen.

Eine Übersicht darüber, wie die Agent Sandbox in der GKE nicht vertrauenswürdigen, KI-generierten Code isoliert, finden Sie unter Agent Sandbox in der GKE.

Kosten

Agent Sandbox in GKE ist eine Open-Source-Software, die Sie ohne zusätzliche Kosten verwenden können. Die GKE-Preise gelten für die von Ihnen erstellten Ressourcen, einschließlich der Rechenressourcen, die der Agent Sandbox-Controller verwendet.

Um unnötige Kosten zu vermeiden, sollten Sie GKE deaktivieren oder das Projekt löschen, nachdem Sie dieses Dokument abgeschlossen haben.

Hinweis

  1. Wählen Sie in der Cloud de Confiance Console auf der Seite für die Projektauswahl ein Projekt von Cloud de Confiance aus oder erstellen Sie eines.

    Erforderliche Rollen zum Auswählen oder Erstellen eines Projekts

    • Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können jedes Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
    • Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Project Creator“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Informationen zum Zuweisen von Rollen

    Zur Projektauswahl

  2. Prüfen Sie, ob die Abrechnung für Ihr Cloud de Confiance -Projekt aktiviert ist.

  3. Aktivieren Sie die Google Kubernetes Engine API, falls sie noch nicht aktiviert ist.

    Rollen, die zum Aktivieren von APIs erforderlich sind

    Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Inhaberrolle (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. Informationen zum Zuweisen von Rollen

    API aktivieren

  4. Aktivieren Sie Cloud Shell in der Cloud de Confiance Console.

    Cloud Shell aktivieren

Umgebungsvariablen definieren

Um die Befehle zu vereinfachen, die Sie in diesem Dokument ausführen, können Sie Umgebungsvariablen in Cloud Shell festlegen. Definieren Sie in Cloud Shell die folgenden nützlichen Umgebungsvariablen, indem Sie die folgenden Befehle ausführen:

export CLUSTER_NAME="agent-sandbox-cluster"
export LOCATION="us-central1"
export AGENT_SANDBOX_VERSION="v1.0.6"
export NODE_POOL_NAME="agent-sandbox-pool"
export MACHINE_TYPE="e2-standard-2"

Hier ist eine Erklärung dieser Umgebungsvariablen:

  • CLUSTER_NAME: der Name Ihres GKE-Cluster, z. B. agent-sandbox-cluster.
  • LOCATION: die Cloud de Confiance by S3NS -Region oder -Zone, in der Ihr GKE-Cluster erstellt wird. Wenn Sie einen Autopilot-Cluster erstellen, legen Sie hier die Region fest (z. B. us-central1). Autopilot-Cluster sind immer regional. Wenn Sie einen Standardcluster erstellen, legen Sie hier die Zone fest (z. B. us-central1-a). Um die Kosten zu senken, wird in diesem Dokument ein zonaler Cluster erstellt, der weniger Knoten als ein regionaler Cluster verwendet.
  • AGENT_SANDBOX_VERSION: Die Version des Open-Source-Agent-Sandbox-Controllers, die installiert werden soll. In diesem Dokument wird Version 1.0.6 verwendet. Weitere Versionen finden Sie auf der Seite mit den Agent Sandbox-Releases.
  • NODE_POOL_NAME: der Name des Knotenpools, in dem Ihre Agent-Pods ausgeführt werden, z. B. agent-sandbox-pool. Diese Variable ist nur erforderlich, wenn Sie einen GKE Standard-Cluster erstellen.
  • MACHINE_TYPE: der Maschinentyp der Knoten im Standardknotenpool des Clusters und im gVisor-Knotenpool, z. B. e2-standard-2. Weitere Informationen zu den verschiedenen Maschinenserien und zur Auswahl zwischen den verschiedenen Optionen finden Sie im Leitfaden zu Ressourcen und Vergleichen für Maschinenfamilien. Diese Variable ist nur erforderlich, wenn Sie einen GKE Standard-Cluster erstellen.

GKE-Cluster erstellen

Agent Sandbox in GKE isoliert Agentenarbeitslasten mithilfe von GKE Sandbox mit gVisor oder microVMs. Wenn Sie keine GKE Sandbox-Laufzeit (gVisor oder MicroVMs) angeben, werden Ihre Pods ohne Kernel-Isolation ausgeführt. Verwenden Sie sie daher nicht zum Ausführen von nicht vertrauenswürdigem Code. In diesem Dokument wird gVisor verwendet. Autopilot-Cluster aktivieren gVisor automatisch. In Standardclustern erstellen Sie einen Knotenpool, für den gVisor aktiviert ist. Wenn Sie stattdessen MicroVMs verwenden möchten, lesen Sie den Abschnitt Sandbox-Typ „microVM“ aktivieren. Die empfohlene Sicherheitsrichtlinie lässt nur gVisor zu, sodass Sandbox-Ressourcen, die MicroVMs verwenden, abgelehnt werden.

Autopilot

Wenn Sie einen Autopilot-Cluster erstellen möchten, muss die Umgebungsvariable LOCATION auf eine Region wie us-central1 festgelegt sein. Führen Sie dann den folgenden Befehl aus:

gcloud container clusters create-auto ${CLUSTER_NAME} \
    --location=${LOCATION}

Standard

Wenn Sie einen Standardcluster erstellen möchten, erstellen Sie den Cluster und fügen dann einen Knotenpool mit aktiviertem gVisor hinzu. Um die Kosten zu senken, wird in diesem Dokument ein zonaler Cluster mit einem einzelnen Knoten pro Pool erstellt.

  1. Legen Sie die Umgebungsvariable LOCATION auf eine Zone fest, z. B. us-central1-a:

    export LOCATION="us-central1-a"
    
  2. Erstellen Sie den Cluster:

    gcloud container clusters create ${CLUSTER_NAME} \
        --location=${LOCATION} \
        --machine-type=${MACHINE_TYPE} \
        --num-nodes=1
    
  3. Erstellen Sie einen separaten Knotenpool mit aktiviertem gVisor:

    gcloud container node-pools create ${NODE_POOL_NAME} \
        --cluster=${CLUSTER_NAME} \
        --machine-type=${MACHINE_TYPE} \
        --location=${LOCATION} \
        --num-nodes=1 \
        --image-type=cos_containerd \
        --sandbox=type=gvisor
    

    Wenn Sie MicroVMs anstelle von gVisor verwenden möchten, erstellen Sie den Knotenpool wie unter Sandbox-Typ „microVM“ aktivieren beschrieben. Im restlichen Teil dieses Dokuments wird gVisor verwendet.

Wenn Sie stattdessen einen vorhandenen Standard-Cluster verwenden möchten, muss der Cluster einen Knotenpool mit aktiviertem gVisor enthalten. Wenn der Cluster keinen solchen Knotenpool hat, erstellen Sie einen mit dem vorherigen gcloud container node-pools create-Befehl.

Damit das kubectl-Befehlszeilentool eine Verbindung zum Cluster herstellen kann, rufen Sie die Cluster-Anmeldedaten ab:

gcloud container clusters get-credentials ${CLUSTER_NAME} \
    --location=${LOCATION}

Agent Sandbox installieren

Wenn Sie die Agent Sandbox installieren möchten, wenden Sie ein Release-Manifest aus dem GitHub-Repository für die Agent Sandbox an. Mit dem Manifest sandbox-with-extensions.yaml werden der Agent Sandbox-Controller und die CustomResourceDefinitions für die Sandbox-Ressource sowie für die Erweiterungsressourcen SandboxTemplate, SandboxClaim und SandboxWarmPool installiert.

  1. Wenden Sie das Release-Manifest an:

    kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml
    

    Das Manifest erstellt den Namespace agent-sandbox-system und stellt den Controller in diesem Namespace bereit.

  2. Warten Sie, bis der Controller bereit ist:

    kubectl rollout status deployment/agent-sandbox-controller \
        --namespace=agent-sandbox-system \
        --timeout=120s
    

Sie können die Agent-Sandbox auch mit Helm installieren. Eine Anleitung finden Sie in der README-Datei zum Helm-Diagramm für die Agent-Sandbox.

Installation überprüfen

  1. Prüfen Sie, ob die CustomResourceDefinitions für die Agent Sandbox installiert sind:

    kubectl get crd \
        sandboxes.agents.x-k8s.io \
        sandboxtemplates.extensions.agents.x-k8s.io \
        sandboxclaims.extensions.agents.x-k8s.io \
        sandboxwarmpools.extensions.agents.x-k8s.io
    

    In der Ausgabe werden die vier CustomResourceDefinitions aufgeführt.

  2. Prüfen Sie, ob der Controller ausgeführt wird:

    kubectl get deployment agent-sandbox-controller \
        --namespace=agent-sandbox-system
    

    Wenn der Controller ausgeführt wird, wird in der Spalte READY der Wert 1/1 angezeigt.

Empfohlene Sicherheitsrichtlinie anwenden

Standardmäßig schränkt die Agent-Sandbox in GKE die Konfiguration der Pods, auf denen Ihre Agents ausgeführt werden, nicht ein. Um die Isolationseinstellungen für Ihre Agent-Pods zu erzwingen, wenden Sie die empfohlene secure-sandbox-policy-ValidatingAdmissionPolicy aus dem GitHub-Repository für die Agent-Sandbox an. Mit dieser Richtlinie werden alle Sandbox-Ressourcen abgelehnt, die die Anforderungen für die Bereitstellung der Agent-Sandbox in GKE nicht erfüllen.

  1. Wenden Sie die Richtlinie an:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-policy.yaml
    
  2. Wenden Sie die Richtlinienbindung an. Die Bindung erzwingt die Richtlinie in allen Namespaces mit Ausnahme von System-Namespaces wie kube-system:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/examples/policy/vap/secure-sandbox-binding.yaml
    

Die Richtlinie validiert Sandbox-Ressourcen. Wenn Sie eine SandboxWarmPool- oder SandboxClaim-Ressource erstellen, erstellt der Controller Sandbox-Ressourcen aus einer SandboxTemplate-Ressource. Wenn die Vorlage die Anforderungen nicht erfüllt, wird die Sandbox-Ressource von der Richtlinie abgelehnt und der Fehler wird in den Controller-Logs angezeigt. Führen Sie den folgenden Befehl aus, um die Logs aufzurufen:

kubectl logs deployment/agent-sandbox-controller \
    --namespace=agent-sandbox-system

Sie sind Inhaber dieser Richtlinie und können sie an Ihre Arbeitslasten anpassen. Weitere Informationen finden Sie unter Sandbox-Sicherheitsrichtlinien.

Anforderungen für die Bereitstellung von Agent Sandbox in GKE

Wenn Sie die empfohlene Sicherheitsrichtlinie anwenden, müssen Ihre Arbeitslastmanifeste, z. B. eine Sandbox- oder SandboxTemplate-Ressource, bestimmte Sicherheits- und Konfigurationseinstellungen enthalten. Wenn eine Sandbox-Ressource diese Anforderungen nicht erfüllt, wird sie vom Admission Controller abgelehnt. Die Containeranforderungen gelten für alle Container im Pod, einschließlich Init-Containern und sitzungsspezifischen Containern.

Erforderliche Konfiguration

Ihr Bereitstellungsmanifest muss die folgenden Einstellungen enthalten:

  • runtimeClassName: gvisor: Führt den Pod in der gVisor-Laufzeit von GKE Sandbox aus. Die Richtlinie lehnt Sandbox-Ressourcen ab, die eine andere Laufzeit verwenden, einschließlich MicroVMs.
  • automountServiceAccountToken: false: Verhindert, dass der Pod das Standarddienstkonto-Token automatisch bereitstellt.
  • securityContext.runAsNonRoot: true: sorgt dafür, dass der Container nicht als Root-Nutzer ausgeführt wird.
  • securityContext.capabilities.drop: ["ALL"]: Entfernt alle Linux-Funktionen aus dem Container.
  • resources.limits: Sie müssen CPU- und Arbeitsspeicherlimits angeben, um potenzielle Denial-of-Service-Szenarien (DoS) zu verhindern.
  • nodeSelector: muss auf sandbox.gke.io/runtime: gvisor ausgerichtet sein.
  • tolerations: muss eine Toleranz für die sandbox.gke.io/runtime=gvisor:NoSchedule-Markierung enthalten.

Unzulässige Konfiguration

Ihr Bereitstellungsmanifest darf Folgendes nicht enthalten:

  • hostNetwork: true, hostPID: true oder hostIPC: true.
  • privileged: true in Containersicherheitskontexten.
  • procMount: Unmasked in Container-Sicherheitskontexten.
  • HostPath Volumes.
  • Zusätzliche Funktionen (capabilities.add).
  • hostPort-Einstellungen.
  • Benutzerdefinierte sysctls.
  • Projizierte Volumes für Dienstkonto-Tokens oder -Zertifikate.

Sandbox-Router bereitstellen (optional)

Der Sandbox-Router ist ein HTTP-Proxy, der Anfragen von Clients, z. B. dem Python-Client für die Agent-Sandbox, an die Pods weiterleitet, auf denen Ihre KI-Agenten ausgeführt werden. Wenn Sie den Python-Client verwenden möchten, z. B. wie unter Isolierte Ausführung von KI-Code mit Agent Sandbox in der GKE beschrieben, stellen Sie den Router bereit.

Sie stellen den Router im Namespace agent-sandbox-system bereit. Standardmäßig lässt die Netzwerkrichtlinie, die die Agent-Sandbox in GKE für jede SandboxTemplate-Ressource erstellt, eingehenden Traffic zu Agent-Pods nur von den Router-Pods in diesem Namespace zu.

  1. Erstellen Sie das Dienstkonto des Routers und die RBAC-Berechtigungen, mit denen der Router nach Agent-Pods suchen kann:

    kubectl apply \
        -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/serviceaccount.yaml \
        -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/rbac.yaml
    
  2. Stellen Sie den Router bereit. Mit dem folgenden Befehl wird das Router-Image auf dieselbe Version wie der Controller festgelegt:

    curl -sSL https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/deployment.yaml \
        | sed "s|sandbox-router-go:latest|sandbox-router-go:${AGENT_SANDBOX_VERSION}|" \
        | kubectl apply -f -
    
  3. Erstellen Sie den Dienst des Routers:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/service.yaml
    
  4. Warten Sie, bis der Router bereit ist:

    kubectl rollout status deployment/sandbox-router \
        --namespace=agent-sandbox-system \
        --timeout=120s
    

Diese Routerkonfiguration ist für die Entwicklung und Tests vorgesehen. Informationen zu Produktionseinstellungen wie TLS, Replikatanzahl und Netzwerkrichtlinien für den Router finden Sie in der README-Datei zur Bereitstellung des Sandbox-Routers.

Controller-Messwerte exportieren (optional)

Der Agent Sandbox-Controller exportiert Prometheus-Messwerte im Pfad /metrics am Port metrics (Port 8080). Wenn Sie diese Messwerte mit Google Cloud Managed Service for Prometheus erfassen und in Cloud Monitoring abfragen möchten, wenden Sie eine benutzerdefinierte PodMonitoring-Ressource an.

Die verwaltete Erfassung ist in GKE standardmäßig in Autopilot-Clustern mit GKE-Version 1.25 oder höher und in Standard-Clustern mit GKE-Version 1.27 oder höher aktiviert. Wenn für Ihren Cluster die verwaltete Erfassung nicht aktiviert ist, lesen Sie den Abschnitt Verwaltete Erfassung manuell aktivieren.

Da Prometheus-Zähler und -Histogramme keine Aktivitäten aufzeichnen, die vor Beginn der Erfassung stattgefunden haben, wenden Sie die PodMonitoring-Ressource nach der Installation des Controllers an, damit Cloud Monitoring frühe Cluster- und Sandbox-Ressourcenereignisse erfasst.

  1. Erstellen Sie in Cloud Shell eine Datei namens agent-sandbox-monitoring.yaml mit folgendem Inhalt:

    apiVersion: monitoring.googleapis.com/v1
    kind: PodMonitoring
    metadata:
      name: agent-sandbox-controller
      namespace: agent-sandbox-system
    spec:
      selector:
        matchLabels:
          app: agent-sandbox-controller
      endpoints:
      - port: metrics
        path: /metrics
        interval: 30s
    
  2. Wenden Sie das Manifest an:

    kubectl apply -f agent-sandbox-monitoring.yaml
    

Nachdem Sie die PodMonitoring-Ressource angewendet haben, werden die Controller-Messwerte alle 30 Sekunden von Google Cloud Managed Service for Prometheus erfasst. Sie können diese Messwerte mit PromQL in Cloud Monitoring über den Metrics Explorer abfragen.

In Cloud Monitoring reserviert Google Cloud Managed Service for Prometheus das Label namespace für den Namespace des gescrapten Controller-Pods (agent-sandbox-system). Bei Messwerten, die ein eigenes namespace-Label definieren, benennt Google Cloud Managed Service for Prometheus das Messwertlabel in exported_namespace um. Wenn Sie Messwerte nach dem Namespace der Sandbox-Ressource filtern oder gruppieren möchten, verwenden Sie das Label exported_namespace. Weitere Informationen finden Sie unter Reservierte Labels.

Sie können beispielsweise die folgenden Messwerte abfragen:

  • agent_sandbox_build_info: Build-Informationen zum Controller, z. B. Git-Commit und -Version.

  • agent_sandboxes: die Anzahl der Sandbox-Ressourcen im Cluster zu einem bestimmten Zeitpunkt. Dieser Messwert hat Labels für Bereitschaft, Ablauf, Starttyp, Inhaber, Ersteller, Vorlage und den Namespace der Sandbox-Ressource (exported_namespace). Die folgende PromQL-Abfrage gruppiert beispielsweise Sandbox-Ressourcen nach Namespace und Bereitschaft:

    sum by (exported_namespace, ready_condition) (agent_sandboxes)
    
  • agent_sandbox_claim_controller_startup_latency_ms: Ein Histogramm, das die Latenz in Millisekunden ab dem Zeitpunkt misst, an dem der Controller zum ersten Mal eine SandboxClaim-Ressource erkennt, bis der Anspruch den Status Ready erreicht. Da es sich bei diesem Messwert um ein Prometheus-Histogramm handelt, werden bei der Abfrage des Basis-Messwertnamens keine Daten direkt zurückgegeben. Sie müssen die _bucket-, _sum- oder _count-Reihe abfragen. Die folgende PromQL-Abfrage berechnet beispielsweise die Startlatenz des 95. Perzentils über ein fünfminütiges Ratenfenster:

    histogram_quantile(
      0.95,
      sum by (le) (
        rate(agent_sandbox_claim_controller_startup_latency_ms_bucket[5m])
      )
    )
    

Weitere Informationen zu exportierten Messwerten und den optionalen Komponenten, von denen sie abhängen, finden Sie in der Referenz zu Controller-Messwerten.

Sandbox-Umgebung bereitstellen

Wenn Sie eine Sandbox-Umgebung bereitstellen möchten, definieren Sie eine SandboxTemplate-Ressource und halten Sie vorgewärmte Sandbox-Ressourcen mit einer SandboxWarmPool-Ressource bereit. Anschließend können Sie mit einer SandboxClaim-Ressource eine Sandbox-Ressource aus diesem Warmpool anfordern. Alternativ können Sie eine Sandbox-Ressource direkt erstellen. Dieser Ansatz unterstützt jedoch keine Warm Pools.

„SandboxTemplate“, „SandboxWarmPool“, „SandboxClaim“ und „Sandbox“ sind benutzerdefinierte Kubernetes-Ressourcen.

Die SandboxTemplate-Ressource fungiert als wiederverwendbarer Entwurf. Die SandboxWarmPool-Ressource verwaltet eine bestimmte Anzahl von vorgewärmten Sandbox-Ressourcen mit laufenden Pods, die bereit sind, beansprucht zu werden. Dieser Warmpool reduziert die Startlatenz.

So stellen Sie eine Sandbox-Umgebung bereit, indem Sie „SandboxTemplate“- und „SandboxWarmPool“-Ressourcen erstellen:

  1. Erstellen Sie in Cloud Shell eine Datei namens sandbox-template.yaml mit folgendem Inhalt:

    apiVersion: extensions.agents.x-k8s.io/v1beta1
    kind: SandboxTemplate
    metadata:
      name: python-runtime-template
      namespace: default
    spec:
      podTemplate:
        metadata:
          labels:
            sandbox-type: python-runtime
        spec:
          runtimeClassName: gvisor # Required
          automountServiceAccountToken: false # Required
          securityContext:
            runAsNonRoot: true # Required
          nodeSelector:
            sandbox.gke.io/runtime: gvisor # Required
          tolerations:
          - key: "sandbox.gke.io/runtime"
            value: "gvisor"
            effect: "NoSchedule" # Required
          containers:
          - name: runtime
            image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0
            ports:
            - containerPort: 8888
            resources:
              requests:
                cpu: "250m"
                memory: "512Mi"
              limits:
                cpu: "500m"
                memory: "1Gi" # Required
            securityContext:
              capabilities:
                drop: ["ALL"] # Required
          restartPolicy: OnFailure
    
  2. Wenden Sie das SandboxTemplate-Manifest an:

    kubectl apply -f sandbox-template.yaml
    
  3. Erstellen Sie eine Datei mit dem Namen sandbox-warmpool.yaml und dem folgendem Inhalt:

    apiVersion: extensions.agents.x-k8s.io/v1beta1
    kind: SandboxWarmPool
    metadata:
      name: python-runtime-warmpool
      namespace: default
      labels:
        app: python-runtime-warmpool
    spec:
      replicas: 2
      sandboxTemplateRef:
        # This must match the name of the SandboxTemplate.
        name: python-runtime-template
    
  4. Wenden Sie das SandboxWarmPool-Manifest an:

    kubectl apply -f sandbox-warmpool.yaml
    
  5. Warten Sie, bis die Sandbox-Ressourcen des warmen Pools und ihre Pods bereit sind:

    kubectl wait sandboxwarmpool python-runtime-warmpool \
        --for=jsonpath='{.status.readyReplicas}'=2 \
        --timeout=600s
    

    Wenn Sie eine SandboxClaim-Ressource erstellen, bevor die Sandbox-Ressourcen des Pools und ihre Pods bereit sind, erstellt der Controller eine neue Sandbox-Ressource für den Claim, anstatt eine aus dem Pool zuzuweisen. In einem Autopilot-Cluster kann es einige Minuten dauern, bis die Pods bereit sind, da GKE möglicherweise Knoten für sie erstellen muss.

SandboxClaim-Ressource erstellen

Die SandboxClaim-Ressource fordert eine Sandbox-Ressource aus dem Warmpool an. Da Sie einen Warmpool erstellt haben, weist der Controller dem Claim eine bereite Sandbox-Ressource (und den zugehörigen ausgeführten Pod) aus dem Pool zu, anstatt eine neue zu erstellen.

Führen Sie die folgenden Schritte aus, um eine Sandbox-Ressource aus dem Warmpool anzufordern, indem Sie eine SandboxClaim-Ressource erstellen:

  1. Erstellen Sie eine Datei mit dem Namen sandbox-claim.yaml und dem folgendem Inhalt:

    apiVersion: extensions.agents.x-k8s.io/v1beta1
    kind: SandboxClaim
    metadata:
      name: sandbox-claim
      namespace: default
    spec:
      warmPoolRef:
        # This must match the name of the SandboxWarmPool.
        name: python-runtime-warmpool
    
  2. Wenden Sie das SandboxClaim-Manifest an:

    kubectl apply -f sandbox-claim.yaml
    
  3. Prüfen Sie, ob die Sandbox-Ressource, die Anforderung und der Warmpool bereit sind:

    kubectl get sandboxwarmpool,sandboxclaim,sandbox,pod
    

Alternative: Sandbox-Ressource direkt erstellen

Wenn Sie die schnellen Startzeiten von Warm Pools nicht benötigen, können Sie eine Sandbox-Ressource direkt ohne Vorlagen bereitstellen.

So stellen Sie eine Sandbox-Umgebung bereit, indem Sie direkt eine Sandbox-Ressource erstellen:

  1. Erstellen Sie eine Datei mit dem Namen sandbox.yaml und dem folgendem Inhalt:

    apiVersion: agents.x-k8s.io/v1beta1
    kind: Sandbox
    metadata:
      name: sandbox-example-2
    spec:
      podTemplate:
        metadata:
          labels:
            sandbox: sandbox-example
        spec:
          runtimeClassName: gvisor
          restartPolicy: OnFailure
          automountServiceAccountToken: false # Required
          securityContext:
            runAsNonRoot: true # Required
            runAsUser: 1000 # Required if image defaults to root (for example, busybox)
          nodeSelector:
            sandbox.gke.io/runtime: gvisor
          tolerations:
          - key: "sandbox.gke.io/runtime"
            value: "gvisor"
            effect: "NoSchedule" # Required
          containers:
          - name: my-container
            image: busybox
            command: ["/bin/sh", "-c"]
            args: ["sleep 3600000; echo 'Container finished successfully'; exit 0"]
            securityContext:
              capabilities:
                drop: ["ALL"] # Required
              allowPrivilegeEscalation: false
            resources:
              limits:
                cpu: "100m"
                memory: "128Mi" # Required
    
  2. Wenden Sie das Sandbox-Manifest an:

    kubectl apply -f sandbox.yaml
    
  3. Prüfen Sie, ob die Sandbox-Ressource ausgeführt wird:

    kubectl get sandbox
    

Agent Sandbox aktualisieren

Wenn Sie die Agent Sandbox aktualisieren möchten, wenden Sie das Release-Manifest für die neue Version an:

export AGENT_SANDBOX_VERSION="NEW_VERSION"
kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml

Ersetzen Sie NEW_VERSION durch die Version, die Sie installieren möchten, z. B. eine Version, die auf der Seite mit den Agent Sandbox-Releases aufgeführt ist.

Lesen Sie vor dem Upgrade die Versionshinweise für die neue Version. Wenn auf Ihrem Cluster eine Version der Agent Sandbox vor 1.0.0 ausgeführt wird, müssen Sie Ihre Ressourcen vor dem Upgrade zur v1beta1 API migrieren, da die v1alpha1 API in Version 1.0.0 entfernt wurde. Eine Anleitung finden Sie im Leitfaden zur API-Migration.

Wenn Sie den Sandbox-Router bereitgestellt oder die empfohlene Sicherheitsrichtlinie angewendet haben, wiederholen Sie diese Schritte für die neue Version.

Agent Sandbox deinstallieren

  1. Prüfen Sie, ob noch Agent-Sandbox-Ressourcen verwendet werden:

    kubectl get sandboxes,sandboxclaims,sandboxwarmpools,sandboxtemplates \
        --all-namespaces
    
  2. Wenn Sie die empfohlene Sicherheitsrichtlinie angewendet haben, löschen Sie die Richtlinienbindung und die Richtlinie:

    kubectl delete validatingadmissionpolicybinding secure-sandbox-binding
    kubectl delete validatingadmissionpolicy secure-sandbox-policy
    
  3. Wenn Sie den Sandbox-Router bereitgestellt haben, löschen Sie seine clusterweiten RBAC-Ressourcen:

    kubectl delete -f https://raw.githubusercontent.com/kubernetes-sigs/agent-sandbox/${AGENT_SANDBOX_VERSION}/sandbox-router/deploy/rbac.yaml
    

    Die anderen Ressourcen des Routers befinden sich im Namespace agent-sandbox-system, der im nächsten Schritt gelöscht wird.

  4. Wenn Sie den Agent Sandbox-Controller, seinen Namespace und seine CustomResourceDefinitions löschen möchten, löschen Sie das Release-Manifest für die installierte Version:

    kubectl delete -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/${AGENT_SANDBOX_VERSION}/sandbox-with-extensions.yaml
    

Ressourcen bereinigen

Löschen Sie den von Ihnen erstellten GKE-Cluster, um zu vermeiden, dass Ihrem Cloud de Confiance by S3NS -Konto Gebühren in Rechnung gestellt werden.

gcloud container clusters delete ${CLUSTER_NAME} \
    --location=${LOCATION} \
    --quiet

Wenn Sie einen Autopilot-Cluster erstellt haben, ist der Standort die Region (z. B. us-central1). Wenn Sie einen Standardcluster erstellt haben, ist der Standort die Zone (z. B. us-central1-a).

Nächste Schritte