Agent Sandbox in GKE aktivieren

In diesem Dokument wird beschrieben, wie Sie das Feature „Agent Sandbox“ in einem Google Kubernetes Engine-Cluster (GKE) aktivieren. Außerdem wird erläutert, wie Sie eine Sandbox-Umgebung im Cluster erstellen, um nicht vertrauenswürdigen Code sicher auszuführen.

Eine Übersicht darüber, wie das Feature „Agent Sandbox“ nicht vertrauenswürdigen von KI generierten Code isoliert, finden Sie unter GKE Agent Sandbox.

Kosten

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

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

Hinweis

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

    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 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 Cloud de Confiance Projekt die Abrechnung aktiviert ist.

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

    Erforderliche Rollen zum Aktivieren von APIs

    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 Cloud de Confiance Console.

    Cloud Shell aktivieren

  5. Prüfen Sie, ob Ihr Cluster die GKE-Version 1.35.2-gke.1269000 oder höher ausführt.

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 CLUSTER_VERSION="1.35.2-gke.1269000"
export NODE_POOL_NAME="agent-sandbox-pool"
export MACHINE_TYPE="e2-standard-2"

Hier eine Erläuterung dieser Umgebungsvariablen:

  • PROJECT_ID: die ID Ihres aktuellen Cloud de Confiance by S3NS 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 Cloud de Confiance by S3NS Region oder Zone, in der Ihr GKE Cluster erstellt wird. Legen Sie diese Variable auf die Region (z. B. us-central1) fest, wenn Sie einen Autopilot-Cluster erstellen, oder auf die Zone (z. B. us-central1-a) wenn Sie einen Standardcluster erstellen.
  • CLUSTER_VERSION: die GKE-Version, die Ihr Cluster ausführt. Für das Feature „Agent Sandbox“ ist die Version 1.35.2-gke.1269000 oder höher erforderlich.
  • NODE_POOL_NAME: der Name des Knotenpools, in dem Sandbox-Arbeitslasten ausgeführt werden, z. B. agent-sandbox-pool. Diese Variable ist nur erforderlich, wenn Sie einen GKE-Standardcluster erstellen.
  • 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. Diese Variable ist nur erforderlich, wenn Sie einen GKE-Standardcluster erstellen.

Agent Sandbox aktivieren

Sie können das Feature „Agent Sandbox“ aktivieren, wenn Sie einen neuen Cluster erstellen oder einen vorhandenen Cluster aktualisieren.

Agent Sandbox beim Erstellen eines neuen GKE-Cluster aktivieren

Für eine vollständig verwaltete Kubernetes-Umgebung empfehlen wir die Verwendung eines Autopilot-Clusters. Informationen zum Auswählen des GKE-Betriebsmodus, der für Ihre Arbeitslasten am besten geeignet ist, finden Sie unter GKE-Betriebsmodus auswählen.

Autopilot

Wenn Sie einen neuen GKE Autopilot-Cluster mit aktivierter Agent Sandbox erstellen möchten, fügen Sie das Flag --enable-agent-sandbox hinzu:

gcloud beta container clusters create-auto ${CLUSTER_NAME} \
    --location=${LOCATION} \
    --cluster-version=${CLUSTER_VERSION} \
    --enable-agent-sandbox

Achten Sie bei einem Autopilot-Cluster darauf, dass die Umgebungsvariable LOCATION auf eine Region festgelegt ist (z. B. us-central1).

Standard

Wenn Sie einen neuen GKE-Standardcluster mit aktivierter Agent Sandbox erstellen möchten, müssen Sie den Cluster erstellen, einen Knotenpool mit aktiviertem gVisor hinzufügen und dann das Feature „Agent Sandbox“ aktivieren. Um Kosten zu sparen, empfehlen wir, einen zonalen Cluster mit einem einzelnen Knoten pro Pool zu erstellen:

  1. Erstellen Sie den Cluster:

    gcloud beta container clusters create ${CLUSTER_NAME} \
    --location=${LOCATION} \
    --num-nodes=1 \
    --cluster-version=${CLUSTER_VERSION}

    Achten Sie bei diesem Standardcluster darauf, dass die Umgebungsvariable LOCATION auf eine Zone festgelegt ist (z. B. us-central1-a).

  2. 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

    Die LOCATION muss dieselbe Zone sein, die Sie beim Erstellen des Clusters verwendet haben.

  3. Aktualisieren Sie den Cluster, um das Feature „Agent Sandbox“ zu aktivieren:

    gcloud beta container clusters update ${CLUSTER_NAME} \
    --location=${LOCATION} \
    --enable-agent-sandbox

Agent Sandbox beim Aktualisieren eines vorhandenen GKE-Cluster aktivieren

Wenn Sie Agent Sandbox in einem vorhandenen Cluster aktivieren möchten, muss der Cluster die Version 1.35.2-gke.1269000 oder höher ausführen.

Achten Sie darauf, dass die Umgebungsvariable LOCATION auf die Region oder Zone festgelegt ist, in der sich Ihr vorhandener Cluster befindet.

  1. Wenn Sie einen GKE-Standardcluster verwenden, basiert Agent Sandbox auf gVisor. Wenn Ihr Standardcluster keinen Knotenpool mit aktiviertem gVisor hat, müssen Sie zuerst einen erstellen:

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

  2. Aktualisieren Sie den Cluster, um das Feature „Agent Sandbox“ zu aktivieren:

    gcloud beta container clusters update ${CLUSTER_NAME} \
    --location=${LOCATION} \
    --enable-agent-sandbox

Konfiguration prüfen

Sie können prüfen, ob das Feature „Agent Sandbox“ aktiviert ist, indem Sie die Clusterbeschreibung untersuchen.

gcloud beta container clusters describe ${CLUSTER_NAME} \
    --location=${LOCATION} \
    --format="value(addonsConfig.agentSandboxConfig.enabled)"

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).

Wenn das Feature erfolgreich aktiviert wurde, gibt der Befehl True zurück.

Anforderungen an die Bereitstellung von Agent Sandbox

Damit Sie eine Arbeitslast wie Sandbox oder SandboxTemplate, Ihr YAML-Manifest muss bestimmte Sicherheits- und Konfigurationseinstellungen enthalten. GKE erzwingt diese Anforderungen mithilfe einer Validating Admission Policy (VAP). Wenn diese Anforderungen nicht erfüllt sind, lehnt der Zulassungscontroller die Bereitstellung ab.

Erforderliche Konfiguration

Ihr Bereitstellungsmanifest muss die folgenden Einstellungen enthalten:

  • runtimeClassName: gvisor: sorgt dafür, dass der Pod in einer gVisor-Sandbox ausgeführt wird.
  • automountServiceAccountToken: false: verhindert, dass das Standarddienstkonto-Token automatisch im Pod bereitgestellt wird.
  • 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 den Taint sandbox.gke.io/runtime=gvisor:NoSchedule enthalten.

Verbotene Konfiguration

Ihr Bereitstellungsmanifest darf keine der folgenden Einstellungen enthalten:

  • hostNetwork: true, hostPID: true oder hostIPC: true.
  • privileged: true in Container-Sicherheitskontexten.
  • HostPath-Volumes.
  • Hinzugefügte Funktionen (capabilities.add).
  • hostPort-Einstellungen.
  • Benutzerdefinierte Sysctls.
  • Projizierte Volumes für Dienstkonto-Tokens oder Zertifikate.

Sandbox-Umgebung bereitstellen

Wir empfehlen, eine Sandbox-Umgebung bereitzustellen, indem Sie eine SandboxTemplate definieren und mit einem SandboxWarmPool vorkonfigurierte Instanzen bereithalten. Anschließend können Sie mit einem SandboxClaim eine Instanz aus diesem vorkonfigurierten Knotenpool anfordern. Alternativ können Sie direkt eine Sandbox erstellen. Dieser Ansatz unterstützt jedoch keine vorkonfigurierten Pools.

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

Das SandboxTemplate dient als wiederverwendbarer Entwurf. Der SandboxWarmPool sorgt dafür, dass immer eine bestimmte Anzahl vorkonfigurierter Pods ausgeführt wird und bereit ist, angefordert zu werden. Durch die Verwendung dieser benutzerdefinierten Ressource wird die Startlatenz minimiert.

So stellen Sie eine Sandbox-Umgebung bereit, indem Sie das SandboxTemplate und den SandboxWarmPool erstellen:

  1. Erstellen Sie in Cloud Shell eine Datei mit dem Namen sandbox-template.yaml und dem folgenden Inhalt:

    apiVersion: extensions.agents.x-k8s.io/v1alpha1
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 folgenden Inhalt:

    apiVersion: extensions.agents.x-k8s.io/v1alpha1
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

SandboxClaim erstellen

Mit dem SandboxClaim wird eine Sandbox aus der Vorlage angefordert. Da Sie einen vorkonfigurierten Pool erstellt haben, verwendet die erstellte Sandbox einen ausgeführten Pod aus dem Pool, anstatt einen neuen Pod zu starten.

So fordern Sie eine Sandbox aus der Vorlage an, indem Sie einen SandboxClaim erstellen:

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

    apiVersion: extensions.agents.x-k8s.io/v1alpha1
kind: SandboxClaim
metadata:
  name: sandbox-claim
  namespace: default
spec:
  sandboxTemplateRef:
    # This must match the name of the SandboxTemplate.
    name: python-runtime-template

  2. Wenden Sie das SandboxClaim-Manifest an:

    kubectl apply -f sandbox-claim.yaml

  3. Prüfen Sie, ob die Sandbox, der Anspruch und der vorkonfigurierte Pool bereit sind:

    kubectl get sandboxwarmpool,sandboxclaim,sandbox,pod

Alternative: Sandbox direkt erstellen

Wenn Sie die schnellen Startzeiten, die durch vorkonfigurierte Pools bereitgestellt werden, nicht benötigen, können Sie eine Sandbox direkt bereitstellen, ohne Vorlagen zu verwenden.

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

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

    apiVersion: agents.x-k8s.io/v1alpha1
kind: Sandbox
metadata:
  name: sandbox-example-2
spec:
  replicas: 1
  podTemplate:
    metadata:
      labels:
        sandbox: sandbox-example
    spec:
      runtimeClassName: gvisor
      restartPolicy: Always
      automountServiceAccountToken: false # Required
      securityContext:
        runAsNonRoot: true # Required
        runAsUser: 1000 # Required if image defaults to root (e.g. 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 ausgeführt wird:

    kubectl get sandbox

Agent Sandbox deaktivieren

Verwenden Sie den Befehl gcloud beta container clusters update mit dem Flag --no-enable-agent-sandbox, um das Feature „Agent Sandbox“ zu deaktivieren.

gcloud beta container clusters update ${CLUSTER_NAME} \
    --location=${LOCATION} \
    --no-enable-agent-sandbox

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).

Ressourcen bereinigen

Löschen Sie den erstellten GKE-Cluster, damit Ihrem Cloud de Confiance by S3NS Konto keine 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