KI-Codeausführung mit Agent Sandbox isolieren

Sie können eine Entwicklungsumgebung bereitstellen, um den Python-Client der Agent Sandbox in einem Google Kubernetes Engine-Cluster (GKE) zu verwenden. Mit dieser Einrichtung können Sie KI-generierten Code sicher ausführen und testen, indem Sie nicht vertrauenswürdigen Code in einer Sandbox-Python-Umgebung isolieren. Diese Isolation ist entscheidend, um Ihr System vor potenziellen Schwachstellen in KI-generiertem Code zu schützen, die Entwicklungsgeschwindigkeit zu erhöhen und sichere Bereitstellungen zu gewährleisten. Eine Übersicht darüber, wie das Feature „Agent Sandbox“ nicht vertrauenswürdigen KI-generierten Code isoliert, finden Sie unter Informationen zur GKE Agent Sandbox.

Kosten

Die Agent Sandbox wird in GKE ohne zusätzliche Kosten angeboten. Die GKE-Preise gelten für die von Ihnen erstellten Ressourcen.

Hinweis

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

    Rollen, die zum Auswählen oder Erstellen eines Projekts erforderlich sind

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

    Zur Projektauswahl

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

  3. Aktivieren Sie die Artifact Registry API und die Kubernetes Engine API.

    Rollen, die zum Aktivieren von APIs erforderlich sind

    Zum Aktivieren von APIs benötigen Sie die IAM-Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin), die die Berechtigung serviceusage.services.enable enthält. Informationen zum Zuweisen von Rollen.

    APIs aktivieren

  4. Aktivieren Sie Cloud Shell in der Google Cloud Console.

    Cloud Shell aktivieren

  5. Prüfen Sie, ob Sie die Berechtigungen haben, die für diese Anleitung erforderlich sind.
  6. Sie benötigen einen GKE-Cluster, in dem das Feature „Agent Sandbox“ aktiviert ist. Wenn Sie keinen haben, folgen Sie der Anleitung unter Agent Sandbox in GKE aktivieren, um einen neuen Cluster zu erstellen oder einen vorhandenen zu aktualisieren.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle „Kubernetes Engine-Administrator “ (roles/container.admin) für das Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen und Verwalten von Sandboxes benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

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 PROJECT_ID=$(gcloud config get project)
export CLUSTER_NAME="agent-sandbox-cluster"
export LOCATION="us-central1"
export NODE_POOL_NAME="agent-sandbox-node-pool"
export MACHINE_TYPE="e2-standard-2"

Hier eine Erläuterung dieser Umgebungsvariablen:

  • PROJECT_ID: die ID Ihres aktuellen Google Cloud Projekts. Durch das Definieren dieser Variablen wird sichergestellt, dass alle Ressourcen, z. B. Ihr GKE-Cluster, im richtigen Projekt erstellt werden.
  • CLUSTER_NAME: der Name Ihres GKE-Cluster, z. B. agent-sandbox-cluster.
  • LOCATION: die Google Cloud Region oder Zone, in der sich Ihr GKE Cluster befindet. Legen Sie dies auf die Region fest (z. B. us-central1), wenn Sie einen Autopilot-Cluster verwenden, oder auf die Zone (z. B. us-central1-a), wenn Sie einen Standard-Cluster verwenden.
  • NODE_POOL_NAME: der Name des Knotenpools, in dem Sandbox-Arbeitslasten ausgeführt werden, z. B. agent-sandbox-node-pool.
  • MACHINE_TYPE: der Maschinentyp der Knoten in Ihrem Knotenpool, z. B. e2-standard-2. Weitere Informationen zu den verschiedenen Maschinenserien und zur Auswahl zwischen verschiedenen Optionen finden Sie im Leitfaden zu Ressourcen und Vergleichen für Maschinenfamilien.

Sandbox-Umgebung bereitstellen

In diesem Abschnitt erfahren Sie, wie Sie den Sandbox-Blueprint (SandboxTemplate) erstellen, den erforderlichen Netzwerkrouter bereitstellen und den Python-Client installieren, mit dem Sie mit der Sandbox interagieren.

Die empfohlene Methode zum Erstellen und Interagieren mit Ihrer Sandbox ist die Verwendung des Python-Clients für die Agentic Sandbox. Dieser Client bietet eine Schnittstelle, die den gesamten Lebenszyklus einer Sandbox vereinfacht, von der Erstellung bis zur Bereinigung. Es handelt sich um eine Python-Bibliothek, mit der Sie Sandboxes programmatisch erstellen, verwenden und löschen können.

Der Client verwendet einen Sandbox-Router als zentralen Einstiegspunkt für den gesamten Traffic. Im in diesem Dokument beschriebenen Beispiel erstellt der Client mit dem Befehl kubectl port-forward einen Tunnel zu diesem Router, sodass Sie keine öffentlichen IP-Adressen freigeben müssen. Die Verwendung von kubectl port-forward ist keine sichere Lösung und sollte auf Entwicklungsumgebungen beschränkt sein.

SandboxTemplate und SandboxWarmPool erstellen

Sie definieren jetzt die Konfiguration für Ihre Sandbox, indem Sie eine SandboxTemplate- und eine SandboxWarmPool-Ressource erstellen. SandboxTemplate dient als wiederverwendbarer Blueprint, mit dem der Agent Sandbox-Controller konsistente, vorkonfigurierte Sandbox-Umgebungen erstellen kann. Die Ressource SandboxWarmPool sorgt dafür, dass immer eine bestimmte Anzahl vorgewärmter Pods ausgeführt wird und bereit ist, in Anspruch genommen zu werden. Eine vorgewärmte Sandbox ist ein ausgeführter Pod, der bereits initialisiert wurde. Durch diese Vorinitialisierung können neue Sandboxes in weniger als einer Sekunde erstellt werden. Außerdem wird die Startlatenz beim Starten einer regulären Sandbox vermieden:

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

    apiVersion: extensions.agents.x-k8s.io/v1alpha1
kind: SandboxTemplate
metadata:
  name: python-runtime-template
  namespace: default
spec:
  podTemplate:
    metadata:
      labels:
        sandbox: python-sandbox-example
    spec:
      runtimeClassName: gvisor
      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: python-runtime
        image: registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0
        ports:
        - containerPort: 8888
        readinessProbe:
          httpGet:
            path: "/"
            port: 8888
          initialDelaySeconds: 0
          periodSeconds: 1
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "1Gi" # Required
        securityContext:
          capabilities:
            drop: ["ALL"] # Required
      restartPolicy: "OnFailure"
---
apiVersion: extensions.agents.x-k8s.io/v1alpha1
kind: SandboxWarmPool
metadata:
  name: python-sandbox-warmpool
  namespace: default
spec:
  replicas: 2
  sandboxTemplateRef:
    name: python-runtime-template

  2. Wenden Sie das Manifest SandboxTemplate und SandboxWarmPool an:

    kubectl apply -f sandbox-template-and-pool.yaml

Sandbox-Router bereitstellen

Der Python-Client, den Sie zum Erstellen und Interagieren mit Sandbox-Umgebungen verwenden, verwendet eine Komponente namens Sandbox-Router, um mit den Sandboxes zu kommunizieren.

In diesem Beispiel verwenden Sie den Entwicklermodus des Clients zum Testen. Dieser Modus ist für die lokale Entwicklung vorgesehen und verwendet den Befehl kubectl port-forward, um einen direkten Tunnel von Ihrem lokalen Computer zum Sandbox-Router-Dienst zu erstellen, der im Cluster ausgeführt wird. Dieser Tunnelansatz macht eine öffentliche IP-Adresse oder eine komplexe Ingress-Einrichtung überflüssig und vereinfacht die Interaktion mit Sandboxes von Ihrer lokalen Umgebung aus.

Führen Sie die folgenden Schritte aus, um den Sandbox-Router bereitzustellen:

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

    # A ClusterIP Service to provide a stable endpoint for the router pods.
apiVersion: v1
kind: Service
metadata:
  name: sandbox-router-svc
  namespace: default
spec:
  type: ClusterIP
  selector:
    app: sandbox-router
  ports:
  - name: http
    protocol: TCP
    port: 8080 # The port the service will listen on
    targetPort: 8080 # The port the router container listens on (from the sandbox_router/Dockerfile)
---
# The Deployment to manage and run the router pods.
apiVersion: apps/v1
kind: Deployment
metadata:
  name: sandbox-router-deployment
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sandbox-router
  template:
    metadata:
      labels:
        app: sandbox-router
    spec:
      # Ensure pods are spread across different zones for HA
      topologySpreadConstraints:
        - maxSkew: 1
          topologyKey: topology.kubernetes.io/zone
          whenUnsatisfiable: ScheduleAnyway
          labelSelector:
            matchLabels:
              app: sandbox-router
      containers:
      - name: router
        image: us-central1-docker.pkg.dev/k8s-staging-images/agent-sandbox/sandbox-router:latest-main
        ports:
        - containerPort: 8080
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 10
        resources:
          requests:
            cpu: "100m"
            memory: "512Mi"
          limits:
            cpu: "1000m"
            memory: "1Gi"
      securityContext:
        runAsUser: 1000
        runAsGroup: 1000

  2. Wenden Sie das Manifest an, um den Router in Ihrem Cluster bereitzustellen:

    kubectl apply -f sandbox-router.yaml

  3. Prüfen Sie, ob die Sandbox-Router-Bereitstellung ordnungsgemäß ausgeführt wird:

    kubectl get deployment sandbox-router-deployment

    Warten Sie, bis in der Spalte READY für die Bereitstellung 2/2 oder 1/1 angezeigt wird.

Python-Client installieren

Nachdem die Clusterkomponenten wie der Sandbox-Router bereitgestellt wurden, besteht der letzte vorbereitende Schritt darin, den Python-Client für die Agentic Sandbox auf Ihrem lokalen Computer zu installieren. Dieser Client ist eine Python-Bibliothek, mit der Sie Sandboxes programmatisch erstellen, verwenden und löschen können. Sie verwenden ihn im nächsten Abschnitt, um die Umgebung zu testen:

  1. Erstellen und aktivieren Sie eine virtuelle Python-Umgebung:

    python3 -m venv .venv
source .venv/bin/activate

  2. Installieren Sie das Clientpaket:

    pip install k8s-agent-sandbox

Sandbox testen

Nachdem alle Einrichtungskomponenten vorhanden sind, können Sie jetzt mit dem Python-Client für die Agentic Sandbox eine Sandbox erstellen und mit ihr interagieren.

  1. Erstellen Sie in Ihrem Verzeichnis agent-sandbox ein Python-Skript namens test_sandbox.py mit folgendem Inhalt:

    from k8s_agent_sandbox import SandboxClient
from k8s_agent_sandbox.models import SandboxLocalTunnelConnectionConfig

# Automatically tunnels to svc/sandbox-router-svc
client = SandboxClient(
    connection_config=SandboxLocalTunnelConnectionConfig()
)

sandbox = client.create_sandbox(template="python-runtime-template", namespace="default")
try:
    print(sandbox.commands.run("echo 'Hello from the sandboxed environment!'").stdout)
except Exception as e:
    print(f"An error occurred: {e}")

  2. Führen Sie das Testskript über Ihr Terminal aus (während die virtuelle Umgebung noch aktiv ist):

    python3 test_sandbox.py

Jetzt sollten Sie die Meldung „Hello from the sandboxed environment!“ sehen, die von der Sandbox ausgegeben wird.

Glückwunsch! Sie haben einen Shell-Befehl in einer sicheren Sandbox ausgeführt. Mit der Methode sandbox.run() können Sie einen beliebigen Shell-Befehl ausführen. Die Agent Sandbox führt den Befehl innerhalb einer sicheren Barriere aus, die die Knoten und andere Arbeitslasten Ihres Clusters vor nicht vertrauenswürdigem Code schützt. Dies bietet eine sichere und zuverlässige Möglichkeit für einen KI-Agenten oder einen automatisierten Workflow, Aufgaben auszuführen.

Wenn Sie das Skript ausführen, übernimmt der SandboxClient alle Schritte für Sie. Er erstellt die Ressource SandboxClaim, um die Sandbox zu starten, wartet, bis die Sandbox bereit ist, und verwendet dann die Methode sandbox.run(), um Bash-Shell-Befehle im sicheren Container auszuführen. Der Client erfasst und gibt dann die stdout dieses Befehls aus. Die Sandbox wird nach Ausführung des Programms automatisch gelöscht.

Wenn eine SandboxClaim-Ressource erstellt wird, wird ein verfügbarer Pod aus dem Warmpool dem Sandbox-Objekt zugewiesen und der Anspruch wird als bereit markiert. Der SandboxWarmPool füllt sich dann automatisch wieder auf, um die konfigurierte Anzahl von Replikaten beizubehalten.

Wenn Sie prüfen möchten, ob eine bestimmte Sandbox in Anspruch genommen oder verfügbar ist, sehen Sie sich die ownerReferences in den Metadaten des Sandbox-Pods an. Wenn der Wert des Felds kind Sandbox ist, wird der Pod verwendet. Wenn der Wert des Felds kind SandboxWarmPool ist, ist der Pod im Leerlauf und wartet darauf, in Anspruch genommen zu werden.

Sandboxes in der Produktion ausführen

In diesem Dokument interagieren Sie über Cloud Shell von außerhalb des Clusters mit Sandboxes. Der Python-Client verwendet Ihre Nutzeranmeldedaten, um sich beim Cluster zu authentifizieren und Sandbox-Ressourcen zu verwalten. Außerdem verwendet er den Befehl kubectl port-forward, um eine Verbindung mit Sandboxes herzustellen. Diese Schritte eignen sich gut für Entwicklungsszenarien.

In einem Produktionsszenario ist eine Controlleranwendung (z. B. ein KI-Orchestrator) für das Erstellen und Verwalten von Sandbox-Ressourcen verantwortlich. Beachten Sie Folgendes, wenn Sie die Agent Sandbox in der Produktion verwenden möchten:

  • Authentifizierung: Ihre Controlleranwendung muss sich beim Cluster-API-Server authentifizieren, um Sandboxes auszuführen. Wie Sie die Authentifizierung konfigurieren, hängt davon ab, wo die Controlleranwendung ausgeführt wird:

    • Wenn die Controlleranwendung als Pod im selben Cluster ausgeführt wird, verwenden Sie Kubernetes RBAC oder Workload Identity-Föderation für GKE mit IAM-Richtlinien, um dem Kubernetes Dienstkonto des Pods die erforderlichen Berechtigungen zum Beobachten von Sandboxes oder zum Ermitteln von Netzwerkendpunkten zu gewähren.
    • Wenn die Controlleranwendung außerhalb des Clusters ausgeführt wird, verwenden Sie die Workload Identity-Föderation, oder IAM-Dienstkonten, um der Anwendung eine Identität zu geben, auf die Sie in Zulassungsrichtlinien verweisen können.

  • Routing: Anfragen vom Python-Client in Ihrer Controlleranwendung müssen den Sandbox-Router in Ihrem Cluster erreichen. Verwenden Sie in der Produktion eine der folgenden Methoden, um eine Netzwerkverbindung herzustellen:

    • Wenn die Controlleranwendung im selben Cluster ausgeführt wird, verwenden Sie die Funktion SandboxDirectConnectionConfig, um die URL und den Port anzugeben, die vom Sandbox-Router-Dienst verwendet werden.
    • Wenn die Controlleranwendung außerhalb des Clusters ausgeführt wird, verwenden Sie die GKE Gateway API um einen internen oder externen Load-Balancer zu erstellen. Verwenden Sie in Ihrem Clientcode die Funktion SandboxGatewayConnectionConfig, um auf Ihr Gateway zu verweisen.

    Weitere Informationen zu diesen Routingmethoden finden Sie in den Nutzungsbeispielen auf GitHub und in den Schritten zur Gateway-Bereitstellung für den Router.

  • Sandbox-Zugriff auf Google Cloud Ressourcen: Wenn Ihr Sandbox-Code Anfragen an Google Cloud APIs wie Cloud Storage senden muss, verwenden Sie eine IAM-Richtlinie mit der Workload Identity-Föderation für GKE , um dem Kubernetes-Dienstkonto, das vom Sandbox-Pod verwendet wird, die für diesen Zugriff erforderlichen Berechtigungen zu gewähren. Da die Standardnetzwerk richtlinie den Zugriff auf den Google Cloud Metadatenserver (169.254.169.254) blockiert, müssen Sie die Netzwerkrichtlinie anpassen, um diesen Traffic zuzulassen.

  • Einschränkungen der Netzwerkrichtlinie: Standardmäßig erzwingt die Agent Sandbox eine strenge Secure-by-Default-Netzwerkposition (networkPolicyManagement: Managed). Unter dieser Position gelten die folgenden Einschränkungen:

    • Ingress wird von allen Quellen außer dem angegebenen Sandbox-Router blockiert.
    • Egress ist zum öffentlichen Internet zulässig, aber Egress zu privaten LAN-Bereichen (RFC 1918), internem Cluster-DNS (CoreDNS) und dem Metadatenserver des Cloud-Anbieters (169.254.0.0/16) wird explizit blockiert.

    Wenn Sie die Workload Identity-Föderation für GKE verwenden oder auf andere private Ressourcen zugreifen möchten, müssen Sie benutzerdefinierte Netzwerkrichtlinien in SandboxTemplate definieren. Ausführliche Konfigurationsdetails und anpassbare Vorlagen (z. B. Air-Gap-Sandboxes oder Workload Identity-Föderation für die GKE-Integration) finden Sie unter Netzwerkrichtlinienverwaltung für die Agent Sandbox.

Sicherheitsrichtlinien für die Sandbox

Um eine Secure-by-Default-Umgebung zu gewährleisten, verwendet das GKE Agent Sandbox-Add-on Kubernetes-Validierungsrichtlinien für die Zulassung (Validating Admission Policies, VAPs), um Sicherheitsbeschränkungen für Sandbox und SandboxTemplate Ressourcen zu erzwingen. Diese Richtlinien werden automatisch angewendet.

Das Add-on unterteilt die Sicherheitserzwingung in ein zweistufiges Richtlinienmodell, um die Flexibilität zu erhöhen. In den folgenden Abschnitten werden diese Richtlinien beschrieben: die streng verwaltete Kernrichtlinie und die anpassbare Härtungsrichtlinie.

Kernrichtlinie (sandbox-core-policy)

Die Kernrichtlinie erzwingt Isolationsanforderungen, die dazu beitragen, die Integrität der Sandbox zu schützen. Diese Richtlinie enthält Regeln, die die Verwendung von gVisor, Netzwerkisolation wie das Deaktivieren von hostNetwork und Dateisystemisolation wie das Blockieren von hostPath erfordern. Da GKE diese Richtlinie über die Einstellung addonmanager.kubernetes.io/mode: Reconcile verwaltet, können Sie diese Kernregeln nicht ändern oder überschreiben.

Härtungsrichtlinie (sandbox-hardening-policy)

Die Härtungsrichtlinie bietet zusätzliche Best Practices für die Sicherheit und Verwaltungsoptionen. Sie erzwingt Einschränkungen wie das Löschen aller Funktionen, das Verhindern des Hinzufügens neuer Funktionen und die Anforderung, dass Container als Nicht-Root-Nutzer mit Ressourcenlimits ausgeführt werden. GKE stellt diese Richtlinie im Modus EnsureExists über die Einstellung addonmanager.kubernetes.io/mode: EnsureExists bereit. Diese Einstellung bedeutet, dass GKE die Richtlinie erstellt, wenn sie fehlt. Sie können die Richtlinie oder ihre Bindung aber bei Bedarf ändern oder löschen.

Härtungseinschränkungen ändern oder entfernen

Da die Härtungsrichtlinie im Modus EnsureExists bereitgestellt wird, erstellt GKE die Richtlinie, wenn sie fehlt, überschreibt aber Ihre Änderungen nicht. Wenn für Ihre Arbeitslasten Ausnahmen von diesen Härtungsregeln erforderlich sind, können Sie die Richtlinie ändern, um bestimmte Einschränkungen zu entfernen, oder die Richtlinienbindung vollständig löschen.

Wenn Sie die Härtungsrichtlinie ändern und eine bestimmte Einschränkung entfernen möchten (z. B. um zuzulassen, dass Container als Root ausgeführt werden oder Ressourcenlimits weggelassen werden), bearbeiten Sie die Ressource ValidatingAdmissionPolicy:

kubectl edit validatingadmissionpolicy sandbox-hardening-policy

Suchen Sie im Texteditor, der sich öffnet, den Abschnitt validations und entfernen oder ändern Sie den Einschränkungsausdruck, der Ihre Arbeitslast blockiert.

Alternativ können Sie die Härtungsrichtlinie für Ihren Cluster vollständig deaktivieren, indem Sie die Richtlinienbindung löschen:

kubectl delete validatingadmissionpolicybinding sandbox-hardening-binding

Bekannte Probleme

In diesem Abschnitt werden bekannte Probleme bei der Verwendung der Agent Sandbox in GKE und Möglichkeiten zur Behebung oder Umgehung dieser Probleme beschrieben.

Sicherheitsrichtlinie blockiert Funktionen bei Verwendung eines Service Mesh

Wenn Sie versuchen, eine Sandbox bereitzustellen, die in einen Service Mesh-Sidecar (z. B. Envoy oder Istio) integriert ist, kann die Erstellung der Sandbox durch die Härtungsrichtlinie mit einem Fehler wie dem folgenden blockiert werden:

sandbox create error: sandboxes.agents.x-k8s.io "claude-cli-claim-managed" is forbidden:
ValidatingAdmissionPolicy 'sandbox-hardening-policy' with binding 'sandbox-hardening-binding'
denied request: Security Violation: Capabilities.add must be empty. You cannot add capabilities.
  • Ursache: Service Mesh-Sidecars verwenden häufig einen Init-Container wie istio-init oder proxy-init. Diese Init-Container erfordern Funktionen wie NET_ADMIN oder NET_RAW, um iptables-Regeln für das transparente Egress-Routing zu konfigurieren. Standardmäßig blockiert die GKE-Härtungsrichtlinie sandbox-hardening-policy alle Funktionserweiterungen in allen Containertypen.
  • Problemumgehung: Da die GKE-Härtungsrichtlinie im Modus EnsureExists bereitgestellt wird, können Sie die ValidatingAdmissionPolicy ändern, um bestimmten vertrauenswürdigen Init-Containern zu erlauben, NET_ADMIN- und NET_RAW-Funktionen anzufordern. Eine Anleitung zum Ändern oder Entfernen dieser Härtungseinschränkungen finden Sie unter Härtungseinschränkungen ändern oder entfernen. Sie können beispielsweise die Validierungsausdrücke oder Variablen der Richtlinie aktualisieren, um vertrauenswürdige Containernamen von der Funktionsregel auszuschließen.

Egress-Latenz oder -Zeitüberschreitung bei der Verbindung zu Google APIs über IPv6

Bei Arbeitslasten in der Sandbox kann es zu Zeitüberschreitungen bei der Verbindung oder zu einer hohen Latenz (bis zu zwei Minuten) kommen, wenn versucht wird, eine Verbindung zu externen Ressourcen oder Google APIs (z. B. Vertex AI oder Cloud Storage) herzustellen.

  • Ursache: Wenn in Ihrem GKE-Cluster Dual-Stack-IPv6 aktiviert ist, gibt die DNS-Auflösung für Google APIs sowohl IPv4- (A) als auch IPv6-Adressen (AAAA) zurück. Einige Algorithmen in Laufzeit-Engines wie Node.js versuchen zuerst, eine Verbindung über IPv6 herzustellen. Wenn Ihre GKE-VPC keine gültige IPv6-Egress-Route hat, z. B. ein Cloud NAT- oder ein Internetgateway für IPv6, reagiert die TCP-Verbindung nicht mehr (weitere Informationen finden Sie unter https://developers.google.com/style/word-list#hang), bis die TCP-SYN-Zeitüberschreitung abläuft. Dann greift die TCP-Verbindung auf IPv4 zurück.

  • Lösung: Führen Sie einen der folgenden Schritte aus, um das Problem zu beheben:

    • IPv6-Egress konfigurieren: Wenn Sie zulassen möchten, dass ausgehender IPv6-Traffic zum Cluster zurückkehrt, konfigurieren Sie ein gültiges IPv6 Cloud NAT oder Internetgateway in Ihrem VPC-Netzwerk.

    • IPv4 in der Arbeitslast bevorzugen: Wenn Sie die IPv4-DNS-Auflösung bevorzugen möchten, konfigurieren Sie die Laufzeit Ihrer Arbeitslast. In einer Node.js-Anwendung können Sie beispielsweise die folgenden Umgebungsvariablen in der Definition von SandboxTemplate festlegen:

      env:
- name: NODE_OPTIONS
  value: "--dns-result-order=ipv4first --no-network-family-autoselection"

Ressourcen bereinigen

Löschen Sie den erstellten GKE-Cluster, damit Ihrem Google Cloud Konto keine Gebühren in Rechnung gestellt werden:

gcloud container clusters delete $CLUSTER_NAME --location=$LOCATION --quiet

Nächste Schritte