KI-Code-Ausführung mit Agent Sandbox in GKE isolieren

In diesem Dokument wird beschrieben, wie Sie KI-generierten Code in einer isolierten Sandbox in einem GKE-Cluster (Google Kubernetes Engine) ausführen. Sie erstellen eine Sandbox-Vorlage und einen Pool von Sandboxen, die im Cluster bereit sind. Anschließend führen Sie ein Python-Skript aus, das eine Sandbox aus dem Pool anfordert und einen Befehl in der Sandbox ausführt. Das Script verwendet den Python-Client für die Agent Sandbox, eine Bibliothek zum Erstellen und Verwalten von Sandboxes.

Wenn Sie nicht vertrauenswürdigen Code in einer Sandbox ausführen, können Sie Ihr System vor potenziellen Sicherheitslücken in KI-generiertem Code schützen, die Entwicklungsgeschwindigkeit erhöhen und die Sicherheit Ihrer Bereitstellungen verbessern. Eine Übersicht darüber, wie die Agent Sandbox in GKE nicht vertrauenswürdigen, KI-generierten Code isoliert, finden Sie unter Agent Sandbox in 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 vom Agent Sandbox-Controller verwendeten Rechenressourcen.

Hinweis

  1. Wählen Sie in der Google Cloud Console auf der Seite für die Projektauswahl ein Projekt von Google Cloud 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 Google Cloud -Projekt aktiviert ist.

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

    Erforderliche Rollen zum Aktivieren von APIs

    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 Google Cloud Console.

    Cloud Shell aktivieren

  5. Prüfen Sie, ob Sie die Berechtigungen haben, die für dieses Dokument erforderlich sind.
  6. Prüfen Sie, ob Sie einen GKE-Cluster haben, auf dem der Agent Sandbox-Controller installiert und der Sandbox-Router bereitgestellt ist. Wenn nicht, führen Sie nur die folgenden Abschnitte von Agent Sandbox in GKE installieren aus und kehren Sie dann zu diesem Dokument zurück:
    1. Umgebungsvariablen definieren
    2. GKE-Cluster erstellen
    3. Agent Sandbox installieren
    4. Sandbox-Router bereitstellen
    Die anderen Abschnitte dieses Dokuments, z. B. Sandbox-Umgebung bereitstellen, müssen Sie nicht ausführen. Später in diesem Dokument erstellen Sie Ihre eigenen SandboxTemplate- und SandboxWarmPool-Ressourcen.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Kubernetes Engine-Administrator (roles/container.admin) für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen und Verwalten von Sandboxen 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 CLUSTER_NAME="agent-sandbox-cluster"
export LOCATION="us-central1"

Hier ist eine Erklärung dieser Umgebungsvariablen:

  • 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. Wenn Sie einen Autopilot-Cluster verwenden, legen Sie hier die Region fest (z. B. us-central1). Wenn Sie einen Standardcluster verwenden, legen Sie hier die Zone fest (z. B. us-central1-a).

Sandbox-Umgebung bereitstellen

In diesem Abschnitt erfahren Sie, wie Sie den Sandbox-Blueprint (eine SandboxTemplate-Ressource) erstellen, den Netzwerkrouter prüfen und den Python-Client installieren, den Sie für die Interaktion mit der Sandbox verwenden.

Die empfohlene Methode zum Erstellen und Interagieren mit Ihrer Sandbox ist die Verwendung des Agentic Sandbox Python-Clients. Dieser Client bietet eine Schnittstelle, die den gesamten Lebenszyklus einer Sandbox von der Erstellung bis zur Bereinigung vereinfacht. 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 Beispiel, das in diesem Dokument beschrieben wird, erstellt der Client mit dem Befehl kubectl port-forward einen Tunnel zu diesem Router, sodass Sie keine öffentlichen IP-Adressen freigeben müssen. Beachten Sie, dass die Verwendung von kubectl port-forward keine sichere Lösung ist und nur in Entwicklungsumgebungen verwendet werden sollte.

SandboxTemplate- und SandboxWarmPool-Ressourcen erstellen

Sie definieren jetzt die Konfiguration für Ihre Sandbox, indem Sie eine SandboxTemplate-Ressource und eine SandboxWarmPool-Ressource erstellen. Die Ressource SandboxTemplate dient als wiederverwendbarer Blueprint, den der Agent Sandbox-Controller verwendet, um konsistente, vorkonfigurierte Sandbox-Umgebungen zu erstellen. Die Ressource SandboxWarmPool sorgt dafür, dass immer eine bestimmte Anzahl von vorgewärmten Pods ausgeführt wird und zur Verfügung steht. 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 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/v1beta1
kind: SandboxTemplate
metadata:
  name: python-sandbox-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/v1beta1
kind: SandboxWarmPool
metadata:
  name: python-sandbox-warmpool
  namespace: default
spec:
  replicas: 2
  sandboxTemplateRef:
    name: python-sandbox-template

  2. Wenden Sie die Manifeste SandboxTemplate und SandboxWarmPool an:

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

  3. Warten Sie, bis die Sandboxen des warmen Pools bereit sind:

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

    Später in diesem Dokument erstellt der Python-Client eine SandboxClaim-Ressource. Wenn der Client die Anforderung erstellt, bevor die Sandboxen des Pools bereit sind, erstellt der Controller möglicherweise eine neue Sandbox für die Anforderung, anstatt eine aus dem Pool zuzuweisen. In einem Autopilot-Cluster kann es mehrere Minuten dauern, bis die Sandboxen bereit sind, da GKE möglicherweise Knoten für sie erstellen muss.

Sandbox-Router prüfen

Der Python-Client, den Sie zum Erstellen und Interagieren mit Sandbox-Umgebungen verwenden, nutzt 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 im Cluster einzurichten. Bei diesem Tunneling-Ansatz ist keine öffentliche IP-Adresse oder komplexe Ingress-Einrichtung erforderlich. Außerdem wird die Interaktion mit Sandboxes aus Ihrer lokalen Umgebung vereinfacht.

Prüfen Sie, ob der Sandbox-Router im Namespace agent-sandbox-system ausgeführt wird:

kubectl get deployment sandbox-router --namespace=agent-sandbox-system

Wenn der Router ausgeführt wird, wird in der Spalte READY angezeigt, dass alle Replikate bereit sind, z. B. 2/2. Wenn der Befehl den Fehler NotFound zurückgibt, stellen Sie den Router bereit. Folgen Sie dazu der Anleitung unter Sandbox-Router bereitstellen.

Python-Client installieren

Nachdem die clusterinternen Komponenten wie der Sandbox-Router bereitgestellt wurden, besteht der letzte Vorbereitungsschritt darin, den Agentic Sandbox Python-Client 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 sie 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. Verwenden Sie dieselbe Version wie der Agent Sandbox-Controller:

    pip install k8s-agent-sandbox==1.0.6

Sandbox testen

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

  1. Erstellen Sie ein Python-Skript mit dem Namen test_sandbox.py und dem folgenden Inhalt:

    from k8s_agent_sandbox import SandboxClient
from k8s_agent_sandbox.models import SandboxLocalTunnelConnectionConfig

# Tunnels to svc/sandbox-router-svc in the agent-sandbox-system namespace.
# cleanup=True deletes the sandbox when the script exits.
client = SandboxClient(
    connection_config=SandboxLocalTunnelConnectionConfig(),
    cleanup=True,
)

sandbox = client.create_sandbox(warmpool="python-sandbox-warmpool", 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 (die virtuelle Umgebung muss noch aktiv sein):

    python3 test_sandbox.py

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

Glückwunsch! Sie haben erfolgreich einen Shell-Befehl in einer sicheren Sandbox ausgeführt. Mit der Methode sandbox.commands.run() können Sie einen beliebigen Shell-Befehl ausführen. Die Agent Sandbox in GKE führt den Befehl innerhalb einer sicheren Barriere aus, die die Knoten Ihres Clusters und andere Arbeitslasten vor nicht vertrauenswürdigem Code schützt. So können KI-Agenten oder automatisierte Workflows Aufgaben sicher und zuverlässig ausführen.

Wenn Sie das Script ausführen, übernimmt SandboxClient alle Schritte für Sie. Sie erstellt die SandboxClaim-Ressource, um die Sandbox zu starten, wartet, bis die Sandbox bereit ist, und verwendet dann die Methode sandbox.commands.run(), um Bash-Shell-Befehle im sicheren Container auszuführen. Der Client erfasst dann die stdout aus diesem Befehl und gibt sie aus. Da das Skript den Parameter cleanup auf True setzt, löscht der Client die Sandbox, wenn das Programm beendet wird.

Wenn eine SandboxClaim-Ressource erstellt wird, wird dem Anspruch eine verfügbare Sandbox aus dem Warmpool zugewiesen und der Anspruch wird als bereit markiert. Die SandboxWarmPool-Ressource wird dann automatisch wieder aufgefüllt, um die konfigurierte Anzahl von Replikaten beizubehalten.

Wenn Sie prüfen möchten, ob eine bestimmte Sandbox beansprucht oder verfügbar ist, sehen Sie sich den ownerReferences in den Metadaten der Sandbox-Ressource an. Wenn der Wert des Felds kind SandboxClaim ist, wird die Sandbox verwendet. Wenn der Wert des Felds kind SandboxWarmPool ist, ist die Sandbox inaktiv und wartet darauf, angefordert zu werden.

Sandboxes in der Produktion ausführen

In diesem Dokument interagieren Sie mit Sandboxes von außerhalb des Clusters mithilfe von Cloud Shell. 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 zu Sandboxes herzustellen. Diese Schritte eignen sich gut für Entwicklungsszenarien.

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

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

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

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

    • Wenn die Controller-Anwendung im selben Cluster ausgeführt wird, verwenden Sie die Funktion SandboxDirectConnectionConfig, um die URL und den Port anzugeben, die der Sandbox-Router-Dienst verwendet.
    • Wenn die Controller-Anwendung 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 Anwendungsbeispielen auf GitHub und in den Gateway-Bereitstellungsschritten 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-ServiceAccount, den der Sandbox-Pod verwendet, die für diesen Zugriff erforderlichen Berechtigungen zu erteilen. Da die Standardnetzwerkrichtlinie den Zugriff auf den Metadatenserver von Google Cloud (169.254.169.254) blockiert, müssen Sie die Netzwerkrichtlinie anpassen, um diesen Traffic zuzulassen.

  • Einschränkungen für Netzwerkrichtlinien: Standardmäßig erzwingt die Agent Sandbox in GKE eine strenge standardmäßig sichere Netzwerkhaltung (networkPolicyManagement: Managed). Für diese Haltung gelten die folgenden Einschränkungen:

    • Eingehender Traffic wird von allen Quellen blockiert, mit Ausnahme des designierten Sandbox-Routers (Pods mit dem Label app: sandbox-router im Namespace agent-sandbox-system).
    • Ausgehender Traffic ist zum öffentlichen Internet zulässig, aber ausgehender Traffic 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 Workload Identity Federation for GKE verwenden oder auf andere private Ressourcen zugreifen möchten, müssen Sie benutzerdefinierte Netzwerkrichtlinien in der Ressource SandboxTemplate definieren. Detaillierte Konfigurationsdetails und anpassbare Vorlagen (z. B. Air-Gap-Sandboxes oder Integration von Workload Identity Federation for GKE) finden Sie unter Agent Sandbox Network Policy Management.

Sandbox-Sicherheitsrichtlinien

Standardmäßig werden in der Agent Sandbox in GKE keine Sicherheitsrichtlinien auf Sandboxes angewendet. Um die Isolierungseinstellungen für Ihre Sandboxes zu erzwingen, wenden Sie die empfohlene Kubernetes Validating Admission Policy (VAP) secure-sandbox-policy aus dem GitHub-Repository für die Agent Sandbox an. Eine Anleitung finden Sie unter Empfohlene Sicherheitsrichtlinie anwenden.

Die Richtlinie erzwingt Isolationsanforderungen, z. B. die Verwendung von gVisor, die Deaktivierung von hostNetwork und die Blockierung von hostPath-Volumes. Die Richtlinie erzwingt auch Härtungsanforderungen, z. B. das Löschen aller Funktionen, das Verhindern des Hinzufügens neuer Funktionen und das Erfordernis, dass Container als Nicht-Root-Nutzer ausgeführt werden und Ressourcenlimits festlegen. Eine vollständige Liste der Anforderungen finden Sie unter Anforderungen für die Bereitstellung von Agent Sandbox in GKE.

Richtlinieneinschränkungen ändern oder entfernen

Da Sie die Richtlinie selbst anwenden, können Sie sie an Ihre Arbeitslasten anpassen. Wenn für Ihre Arbeitslasten Ausnahmen von einigen der Regeln erforderlich sind, können Sie die Richtlinie ändern, um bestimmte Einschränkungen zu entfernen, oder die Richtlinienbindung vollständig löschen. Wenn Sie eine Einschränkung entfernen, wird die Isolation, die die Richtlinie bietet, reduziert. Entfernen Sie daher nur die Einschränkungen, die für Ihre Arbeitslasten erforderlich sind.

Wenn Sie die Richtlinie ändern und eine bestimmte Einschränkung entfernen möchten (z. B. um Container als Root auszuführen oder Ressourcenlimits wegzulassen), bearbeiten Sie die Ressource ValidatingAdmissionPolicy:

kubectl edit validatingadmissionpolicy secure-sandbox-policy

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

Wenn Sie die Richtlinie in Ihrem Cluster nicht mehr erzwingen möchten, löschen Sie die Richtlinienbindung:

kubectl delete validatingadmissionpolicybinding secure-sandbox-binding

Bekannte Probleme

In diesem Abschnitt werden bekannte Probleme bei der Verwendung von Agent Sandbox in GKE und deren Behebung oder Umgehung beschrieben.

Sicherheitsrichtlinie blockiert Funktionen bei Verwendung eines Service Mesh

Wenn Sie die empfohlene Sicherheitsrichtlinie angewendet haben und versuchen, eine Sandbox bereitzustellen, die in einen Service Mesh-Sidecar (z. B. Envoy oder Istio) eingebunden ist, wird die Erstellung der Sandbox möglicherweise durch die Richtlinie blockiert. Es wird dann ein Fehler wie der folgende angezeigt:

sandbox create error: sandboxes.agents.x-k8s.io "claude-cli-claim-managed" is forbidden:
ValidatingAdmissionPolicy 'secure-sandbox-policy' with binding 'secure-sandbox-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 transparentes ausgehendes Routing zu konfigurieren. Die ValidatingAdmissionPolicy secure-sandbox-policy blockiert alle Capability-Ergänzungen in allen Containertypen.
  • Problemumgehung: Da Sie diese Richtlinie in Ihrem Cluster verwalten, können Sie die ValidatingAdmissionPolicy so ändern, dass bestimmte vertrauenswürdige Init-Container die Funktionen NET_ADMIN und NET_RAW anfordern können. Eine Anleitung zum Ändern oder Entfernen von Richtlinieneinschränkungen finden Sie unter Richtlinieneinschränkungen ändern oder entfernen. Sie können beispielsweise die Validierungsausdrücke oder Variablen der Richtlinie aktualisieren, um vertrauenswürdige Containernamen von der Funktionsregel auszunehmen.

Latenz oder Zeitüberschreitung bei ausgehendem Traffic beim Herstellen einer Verbindung zu Google APIs über IPv6

Bei Arbeitslasten in der Sandbox kann es zu Verbindungszeitüberschreitungen oder hoher 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-Route für ausgehenden Traffic hat, z. B. Cloud NAT oder ein Internetgateway für IPv6, reagiert die TCP-Verbindung nicht mehr, bis das TCP-SYN-Zeitlimit abläuft. Anschließend wird die TCP-Verbindung auf IPv4 zurückgesetzt.

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

    • Ausgehenden IPv6-Traffic konfigurieren: Damit ausgehender IPv6-Traffic zum Cluster zurückkehren kann, konfigurieren Sie ein gültiges IPv6-Cloud NAT- oder Internet-Gateway 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 Ihrer SandboxTemplate-Definition festlegen:

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

Ressourcen bereinigen

Um zu vermeiden, dass Ihrem Google Cloud -Konto Gebühren in Rechnung gestellt werden, sollten Sie den von Ihnen erstellten GKE-Cluster löschen:

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

Nächste Schritte