Secure AI Agents in GKE bereitstellen

1. Einführung

In diesem Lab geht es um die Entwicklung und Sicherheit von KI-Agents, die dynamischen Code in einer Produktionsumgebung ausführen. Da KI-Anwendungen über einfache Chat-Oberflächen hinausgehen, müssen sie oft komplexe Logik ausführen können, z. B. Datenanalyse, mathematische Modellierung oder Dateiverarbeitung. Dazu wird Code in Echtzeit generiert und ausgeführt. In diesem Lab wird gezeigt, wie Sie mit dem Agent Development Kit (ADK) Reasoning Agents erstellen und mit der GKE Agent Sandbox dafür sorgen, dass der von der KI generierte Code in einer hochgradig isolierten, sicheren Umgebung ausgeführt wird.

Die technische Herausforderung von nicht vertrauenswürdigem Code

Wenn ein KI-Agent Code wie Python generiert und ausführt, wird im Grunde eine nicht vertrauenswürdige Arbeitslast auf Ihrer Infrastruktur ausgeführt. Wenn der Agent manipuliert wird oder Anweisungen zum Ausführen schädlicher Aktionen erhält, kann er versuchen, auf vertrauliche Umgebungsvariablen zuzugreifen, Ihr internes Netzwerk zu scannen oder den zugrunde liegenden Hostknoten auszunutzen. Die herkömmliche Containerisolierung reicht für diese dynamischen Arbeitslasten oft nicht aus. Um dieses Problem zu beheben, müssen Plattformtechniker eine mehrschichtige Sicherheit implementieren, die die Isolation auf Kernelebene und eingeschränkten Netzwerk-Egress umfasst.

Wichtige Konzepte

  • Agent Development Kit (ADK): Das ADK ist ein Framework zum Erstellen von Anwendungen, die Aufgaben analysieren können. Sie verwaltet einen „Reasoning Loop“, in dem die KI einen Prompt erhält, eine Reihe von Aktionen plant, bestimmte Tools aufruft und dann die endgültige Ausgabe zusammenfasst. In diesem Workflow fungiert das ADK als Orchestrator, der erkennt, wann für eine Nutzeranfrage die Ausführung von Code erforderlich ist.
  • GKE Agent Sandbox:Diese Sicherheitsfunktion nutzt gVisor, eine Open-Source-Containerlaufzeit, die für jeden Container einen speziellen Gastkernel bereitstellt. Durch das Abfangen von Systemaufrufen (Syscalls) zwischen der Anwendung und dem Host-Kernel verhindert GKE Agent Sandbox, dass nicht vertrauenswürdiger Code direkt mit dem Knoten interagiert. So wird verhindert, dass sich eine Sicherheitslücke im Container auf den Rest des Clusters ausweitet.
  • Model Context Protocol (MCP) und Tools:Dieses Protokoll legt eine Standardmethode für die Interaktion von KI-Modellen mit externen Tools fest. In diesem Lab ist der Agent mit einem Tool zur Codeausführung konfiguriert, das mit einem speziellen Sandbox-Controller kommuniziert, um Python-Skripts auszuführen.

Lernziele des Labs

Am Ende dieses Trainings können Sie:

  1. Agent entwickeln:Konfigurieren Sie einen ADK-basierten Agenten, der für Datenanalyseaufgaben entwickelt wurde.
  2. Kernel-Isolation konfigurieren:Richten Sie GKE Agent Sandbox mit speziellen RuntimeClasses ein.
  3. Leistung optimieren:Implementieren Sie einen „Warm Pool“ von Sandboxes, um die Zeit für das Starten neuer Ausführungsumgebungen zu minimieren.
  4. Sicherheitsgrenzen erzwingen:Wenden Sie Netzwerkrichtlinien an, um unbefugten ausgehenden Traffic aus der Ausführungsumgebung zu verhindern.

2. Projekt einrichten

Eine korrekt konfigurierte Umgebung ist unerlässlich, bevor Sie mit der Entwicklung von Anwendungen mit KI-Agenten beginnen. In diesem Abschnitt greifen Sie auf die erforderlichen Tools zu und sorgen dafür, dass Ihr Google Cloud-Projekt sowohl den KI-Agent als auch seine sichere Ausführungsumgebung hosten kann.

Cloud Shell öffnen

In diesem Lab verwenden wir Cloud Shell, eine browserbasierte Terminalumgebung von Google Cloud. Cloud Shell ist mit der Google Cloud CLI (gcloud), kubectl und der Docker-Umgebung vorkonfiguriert, die zum Erstellen und Bereitstellen Ihrer Anwendung erforderlich ist.

  1. Rufen Sie die Google Cloud Console auf.
  2. Klicken Sie rechts oben in der Kopfzeile auf die Schaltfläche Cloud Shell aktivieren (das Symbol >_).
  3. Wenn sich das Terminal unten in Ihrem Browser öffnet, klicken Sie bei Aufforderung auf Weiter.

Projekt auswählen

Sie müssen dafür sorgen, dass Ihre Shell auf das richtige Google Cloud-Projekt verweist, damit Ressourcen nicht in der falschen Umgebung bereitgestellt werden.

👉💻 Suchen Sie auf dem Konsolen-Dashboard nach Ihrer Projekt-ID und führen Sie den folgenden Befehl aus, um das Projekt in der aktuellen Shell festzulegen:

gcloud config set project [YOUR_PROJECT_ID]

APIs aktivieren

Für die Entwicklung und Bereitstellung von Agents sind mehrere spezielle APIs für Container-Builds, Image-Hosting und den Zugriff auf generative Modelle erforderlich.

👉💻 Führen Sie den folgenden Befehl aus, um diese Dienste zu initialisieren:

gcloud services enable \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    container.googleapis.com \
    aiplatform.googleapis.com
  • cloudbuild.googleapis.com::Automatisiert die Erstellung von Container-Images aus Ihrem Quellcode.
  • artifactregistry.googleapis.com::Bietet eine sichere, private Registry für Ihre Agent-Images.
  • container.googleapis.com::Verwaltet den Lebenszyklus des GKE-Clusters und seiner Sicherheitsfunktionen.
  • aiplatform.googleapis.com::Bietet Zugriff auf Vertex AI-Dienste, einschließlich Gemini-Modelle für Schlussfolgerungen und Codegenerierung.

Clustererstellung

Für dieses Lab ist ein GKE-Cluster mit aktivierter Agent Sandbox-Funktion erforderlich. GKE Autopilot ist die effizienteste Methode für den Einstieg, da die Knotenverwaltung automatisch erfolgt und die für die isolierte Codeausführung erforderlichen Sicherheitsfunktionen unterstützt werden.

👉💻 Führen Sie die folgenden Befehle aus, um den GKE-Cluster zu erstellen:

export PROJECT_ID=$(gcloud config get-value project)

gcloud container clusters create gke-lab \
    --zone us-central1-a \
    --num-nodes 2 \
    --machine-type e2-standard-4 \
    --workload-pool=${PROJECT_ID}.svc.id.goog

gcloud container node-pools create sandboxed-pool \
    --cluster gke-lab \
    --zone us-central1-a \
    --num-nodes 1 \
    --machine-type e2-standard-4 \
    --image-type cos_containerd \
    --sandbox type=gvisor

Hinweis: Die Bereitstellung eines neuen Clusters dauert in der Regel 8 bis 10 Minuten. Sie können APIs in einem neuen Tab oder während der Verarbeitung des Befehls aktivieren.

kubectl-Zugriff konfigurieren

Nachdem Ihr Cluster bereitgestellt wurde, müssen Sie kubectl für die Kommunikation mit dem Cluster konfigurieren.

👉💻 Mit dem folgenden Befehl werden Clusteranmeldedaten abgerufen und Ihre lokale kubeconfig-Datei wird aktualisiert. So können Sie Befehle für Ihren neuen GKE-Cluster über Cloud Shell ausführen:

gcloud container clusters get-credentials gke-lab --zone us-central1-a

kubectl-Befehle werden jetzt standardmäßig auf den gke-lab-Cluster ausgerichtet.

GKE-Zugriff auf Vertex AI zulassen

Damit der Agent, der in GKE ausgeführt wird, auf Vertex AI-Dienste für die Modellinferenz zugreifen kann, müssen Sie Workload Identity konfigurieren. So können Sie ein Kubernetes-Dienstkonto an eine Google Cloud IAM-Rolle binden und Pods, die als dieses Dienstkonto ausgeführt werden, die erforderlichen Berechtigungen gewähren, ohne dass Sie Dienstkontoschlüssel verwalten müssen.

👉💻 Erstellen Sie zuerst das Kubernetes-Dienstkonto, das von den Agent-Pods verwendet wird:

kubectl create serviceaccount adk-agent-sa

Weisen Sie diesem Dienstkonto als Nächstes die Rolle Vertex AI User zu, indem Sie eine IAM-Richtlinienbindung hinzufügen.

👉💻 Mit diesem Befehl wird das Kubernetes-Dienstkonto adk-agent-sa im Namespace default an die IAM-Rolle roles/aiplatform.user für den Workload Identity-Pool Ihres Projekts gebunden.

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")

gcloud projects add-iam-policy-binding projects/${PROJECT_ID} \
    --role=roles/aiplatform.user \
    --member=principal://iam.googleapis.com/projects/${PROJECT_NUMBER}/locations/global/workloadIdentityPools/${PROJECT_ID}.svc.id.goog/subject/ns/default/sa/adk-agent-sa \
    --condition=None

3. ADK-Agent erstellen

In diesem Abschnitt definieren Sie die Logik für Ihren Agenten. Der Agent fungiert als Datenspezialist, der Python-Code zum Verarbeiten von Dateien schreiben kann. Dank dieser Logik kann der Agent erkennen, wann für die Anfrage eines Nutzers in natürlicher Sprache eine mathematische oder datengesteuerte Berechnung erforderlich ist, die am besten durch Code ausgeführt wird.

Agent-Verzeichnis erstellen

👉💻 Erstellen Sie ein Verzeichnis für das Lab und ein Unterverzeichnis für den Quellcode des KI-Agenten:

mkdir -p ~/gke-sandbox-lab/root_agent
cd ~/gke-sandbox-lab

ADK-Agent definieren

Zuerst definieren wir die Kernlogik des Agenten. Unser Agent verwendet das ADK-Framework, um einen Agenten namens SpreadsheetAnalyst zu definieren, der das Modell gemini-2.5-flash verwendet. Es enthält ein Tool (run_spreadsheet_analysis), das die GKE Agent Sandbox aufruft, um Python-Code sicher auszuführen. Die Anweisungen des KI-Agents weisen ihn an, pandas-basierten Code zu schreiben und auszuführen, wenn er aufgefordert wird, Tabellen zu analysieren.

👉💻 Führen Sie den folgenden Befehl aus, um eine Datei mit dem Namen root_agent/agent.py mit dem folgenden Inhalt zu erstellen:

cat <<'EOF' > ~/gke-sandbox-lab/root_agent/agent.py
import pandas as pd
from google.adk.agents import Agent
from k8s_agent_sandbox import SandboxClient

# Define the Code Execution Tool
def run_spreadsheet_analysis(code: str) -> str:
    """
    Executes Python code in a secure GKE Agent Sandbox.
    Use this tool to run pandas-based analysis on spreadsheet data.
    Input should be a complete Python script.
    """
    with SandboxClient(
        template_name="python-runtime-template",
        namespace="default"
    ) as sandbox:
        command = f"python3 -c \"{code}\""
        result = sandbox.run(command)
        
        if result.stderr:
            return f"Error: {result.stderr}"
        return result.stdout

# Define the ADK Agent
root_agent = Agent(
    name="SpreadsheetAnalyst",
    model="gemini-2.5-flash",
    instruction="""
    You are an expert data analyst. When a user asks to analyze a spreadsheet:
    1. Reason about what Python code (using pandas) is needed.
    2. Write the code, ensuring it handles data loading and analysis.
    3. Do not ever use double-quotes for string, always use single-quotes.
    4. Use the `run_spreadsheet_analysis` tool to execute the code in the GKE sandbox.
    5. Provide a clear summary of the analysis based on the tool's output.
    
    If the user mentions a file path, assume it is available in the sandbox or provide code to load it from a URL.
    """,
    tools=[run_spreadsheet_analysis]
)
EOF

Damit das ADK die Agentendefinition aus agent.py erkennen und laden kann und Informationen zu unserem Agenten erhält, sorgen wir dafür, dass root_agent als Python-Paket erkannt wird.

👉💻 Führen Sie den folgenden Befehl aus, um eine leere Datei mit dem Namen root_agent/__init__.py mit folgendem Inhalt zu erstellen:

cat <<'EOF' > ~/gke-sandbox-lab/root_agent/__init__.py
from . import agent
EOF

Anschließend erstellen wir eine Datei, in der Umgebungsvariablen für den ADK-Agent konfiguriert werden. GOOGLE_GENAI_USE_VERTEXAI=TRUE weist das ADK an, Vertex AI für den Zugriff auf Gemini-Modelle zu verwenden. GOOGLE_CLOUD_PROJECT und GOOGLE_CLOUD_LOCATION geben das Google Cloud-Projekt und die Region an, die für Vertex AI API-Aufrufe verwendet werden sollen.

👉💻 Führen Sie den folgenden Befehl aus, um eine Datei mit dem Namen root_agent/.env mit dem folgenden Inhalt zu erstellen:

cat <<EOF > ~/gke-sandbox-lab/root_agent/.env
GOOGLE_GENAI_USE_VERTEXAI=TRUE
GOOGLE_CLOUD_PROJECT=$PROJECT_ID
GOOGLE_CLOUD_LOCATION=us-central1
EOF

Agent containerisieren

Schließlich definieren wir das Container-Image für den Agenten. Es beginnt mit einem Python-Basis-Image, installiert kubectl (erforderlich für die Kommunikation des Agent-Sandbox-Clients mit dem Cluster) und installiert die erforderlichen Python-Bibliotheken: google-adk, pandas und agentic-sandbox-client aus dem zugehörigen Git-Repository. Schließlich wird der Quellcode des Agents in das Image kopiert und der Einstiegspunkt für die Ausführung des ADK-Webservers festgelegt, über den die Benutzeroberfläche und die API des Agents verfügbar gemacht werden.

👉💻 Führen Sie den folgenden Befehl aus, um eine Datei mit dem Namen Dockerfile mit dem folgenden Inhalt zu erstellen:

cat <<'EOF' > ~/gke-sandbox-lab/Dockerfile
FROM python:3.14-slim

ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1

WORKDIR /app

RUN apt-get update && apt-get install -y \
    git \
    curl \
    && curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl" \
    && install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl \
    && rm kubectl \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

RUN pip install --no-cache-dir google-adk pandas "git+https://github.com/kubernetes-sigs/agent-sandbox.git@main#subdirectory=clients/python/agentic-sandbox-client"

COPY ./root_agent /app/root_agent

WORKDIR /app

EXPOSE 8080

ENTRYPOINT ["adk", "web", "--host", "0.0.0.0", "--port", "8080"]
EOF

Agent-Image erstellen

Der Agent muss als Container-Image verpackt sein. Wir verwenden Cloud Build, um den Agent zu verpacken und in Artifact Registry zu speichern.

👉💻 Führen Sie den folgenden Befehl aus, um das Repository zu erstellen:

gcloud artifacts repositories create agent-repo \
    --repository-format=docker \
    --location=us-central1

👉💻 Führen Sie den folgenden Befehl aus, um das Image zu erstellen:

gcloud builds submit --tag us-central1-docker.pkg.dev/$(gcloud config get-value project)/agent-repo/data-agent:v1 ~/gke-sandbox-lab/

4. Sandbox-Infrastruktur implementieren

Nachdem die Agent-Logik definiert wurde, müssen Sie die Infrastruktur konfigurieren, die es ermöglicht, nicht vertrauenswürdigen Code sicher auszuführen. Dazu gehört das Einrichten der Isolationslaufzeit und der Netzwerksteuerung.

Agent Sandbox Controller bereitstellen

Sie können den Agent Sandbox-Controller und die erforderlichen Komponenten bereitstellen, indem Sie die offiziellen Release-Manifeste auf Ihren Cluster anwenden. Diese Manifeste sind Konfigurationsdateien, die Kubernetes anweisen, alle erforderlichen Komponenten herunterzuladen, die für die Bereitstellung und Ausführung des Agent Sandbox-Controllers in Ihrem Cluster erforderlich sind.

👉💻 Führen Sie die folgenden Befehle aus, um den Agent Sandbox-Controller in Ihrem GKE-Cluster bereitzustellen:

kubectl apply \
-f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.1.0/manifest.yaml \
-f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.1.0/extensions.yaml

Sandbox-Vorlage und Sandbox-Warmpool erstellen

Sie definieren jetzt die Konfiguration für Ihre Sandbox, indem Sie eine SandboxTemplate- und eine SandboxWarmPool-Ressource erstellen. Das SandboxTemplate dient als wiederverwendbarer Blueprint, mit dem der Controller der KI-Agenten-Sandbox konsistente, vorkonfigurierte Sandbox-Umgebungen erstellt. Die SandboxWarmPool-Ressource sorgt dafür, dass immer eine bestimmte Anzahl von vorgewärmten Pods ausgeführt wird und bereit ist, in Anspruch genommen zu werden. Eine vorab aufgewärmte Sandbox ist ein laufender 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.

👉💻 Führen Sie den folgenden Befehl aus, um eine Datei mit dem Namen sandbox-template-and-pool.yaml zu erstellen:

cat <<EOF > ~/gke-sandbox-lab/sandbox-template-and-pool.yaml
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
      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"
            ephemeral-storage: "512Mi"
      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
EOF

👉💻 Konfiguration anwenden:

kubectl apply -f ~/gke-sandbox-lab/sandbox-template-and-pool.yaml

Sandbox-Router erstellen

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

👉💻 Führen Sie den folgenden Befehl aus, um eine Datei mit dem Namen sandbox-router.yaml zu erstellen:

cat <<EOF > ~/gke-sandbox-lab/sandbox-router.yaml
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
    targetPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: sandbox-router-deployment
  namespace: default
spec:
  replicas: 2
  selector:
    matchLabels:
      app: sandbox-router
  template:
    metadata:
      labels:
        app: sandbox-router
    spec:
      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:v20260225-v0.1.1.post3-10-ga5bcb57
        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: "250m"
            memory: "512Mi"
          limits:
            cpu: "1000m"
            memory: "1Gi"
      securityContext:
        runAsUser: 1000
        runAsGroup: 1000
EOF

👉💻 Konfiguration anwenden:

kubectl apply -f ~/gke-sandbox-lab/sandbox-router.yaml

Netzwerkisolation implementieren

Damit der generierte Code nicht auf sensible Daten zugreifen kann, müssen Sie eine Netzwerkrichtlinie anwenden. Diese Richtlinie sorgt dafür, dass die Sandbox-Pods den Google Cloud-Metadatenserver oder andere interne IPs nicht erreichen können.

👉💻 Führen Sie den folgenden Befehl aus, um eine Datei mit dem Namen sandbox-policy.yaml zu erstellen:

cat <<EOF > ~/gke-sandbox-lab/sandbox-policy.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: restrict-sandbox-egress
spec:
  podSelector:
    matchLabels:
      sandbox: python-sandbox
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0
        except:
        - 169.254.169.254/32 # Block metadata server
EOF

👉💻 Richtlinie anwenden:

kubectl apply -f ~/gke-sandbox-lab/sandbox-policy.yaml

5. Bereitstellung und Überprüfung

Nachdem Sie den KI-Agent und die Sicherheitsinfrastruktur konfiguriert haben, stellen Sie die Komponenten bereit und prüfen, ob die Sicherheitsgrenzen wie erwartet funktionieren.

KI-Agenten bereitstellen

Jetzt erstellen Sie das Kubernetes-Manifest für die Bereitstellung des ADK-Agents. Dieses Manifest enthält mehrere wichtige Komponenten: ein Deployment zum Verwalten des Container des Agents, ein Service vom Typ LoadBalancer, um die UI und den API-Endpunkt des Agents für externen Traffic freizugeben, und die erforderlichen RBAC-Regeln (Role und RoleBinding), um dem Agent die Berechtigung zu erteilen, mit dem Agent Sandbox-Controller zu interagieren und Sandbox-Instanzen zu verwalten.

👉💻 Führen Sie den folgenden Befehl aus, um eine Datei mit dem Namen deployment.yaml zu erstellen:

cat <<EOF > ~/gke-sandbox-lab/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: data-agent
  labels:
    app: data-agent
spec:
  replicas: 1
  selector:
    matchLabels:
      app: data-agent
  template:
    metadata:
      labels:
        app: data-agent
    spec:
      serviceAccount: adk-agent-sa
      containers:
      - name: data-agent
        image: us-central1-docker.pkg.dev/$PROJECT_ID/agent-repo/data-agent:v1
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: data-agent-service
spec:
  selector:
    app: data-agent
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: sandbox-creator-role
rules:
# 1. Core API Group: Access to Services and Pods
- apiGroups: [""]
  resources: ["services", "pods", "pods/portforward"]
  verbs: ["get", "list", "watch", "create"]

# 2. Rules for Sandbox Claims
- apiGroups: ["extensions.agents.x-k8s.io"]
  resources: ["sandboxclaims"]
  verbs: ["create", "get", "list", "watch", "delete"]

# 3. Rules for the actual Sandboxes
- apiGroups: ["agents.x-k8s.io"]
  resources: ["sandboxes"]
  verbs: ["get", "list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: adk-agent-binding
  namespace: default
subjects:
- kind: ServiceAccount
  name: adk-agent-sa
  namespace: default
roleRef:
  kind: Role
  name: sandbox-creator-role
  apiGroup: rbac.authorization.k8s.io
EOF

👉💻 Konfiguration anwenden:

kubectl apply -f ~/gke-sandbox-lab/deployment.yaml

ADK-Web-UI öffnen

Nach Abschluss der Bereitstellung können Sie ihren Status prüfen.

👉💻 Prüfen Sie, ob die Agent-Pods ausgeführt werden:

kubectl get pods

👉💻 Rufen Sie die externe IP-Adresse ab und suchen Sie die externe IP-Adresse, die dem Agent-Dienst zugewiesen ist:

kubectl get services

Suchen Sie nach dem EXTERNAL-IP-Wert, der mit dem data-agent-service verknüpft ist.

Öffnen Sie die ADK-Web-UI, indem Sie in Ihrem Webbrowser zu http:// wechseln und durch die Adresse aus dem vorherigen Schritt ersetzen.

Legitime Aufgaben bestätigen

Testen Sie den Agent mit einer Standarddatenanfrage, um sicherzustellen, dass die Kommunikation zwischen dem Agent, dem Controller und der Sandbox funktioniert.

  • 👉💬 Prompt:
Here is some inventory data in CSV format. Can you calculate the total value of all items in inventory?
product,quantity,msrp
Laptop,10,1200
Keyboard,50,75
Mouse,75,25
Monitor,20,300
Webcam,40,50
  • Beobachtung:Der Agent generiert Python-Code, um die CSV-Daten zu parsen, multipliziert die Menge für jedes Produkt mit der UVP, summiert den Gesamtwert und gibt das Ergebnis zurück.

Sicherheitsgrenzen überprüfen

Testen Sie die Effektivität der GKE Agent Sandbox, indem Sie versuchen, eingeschränkte Vorgänge auszuführen.

  1. Systemisolationstest
      :
    • 👉💬 Prompt: Write a Python script to list the contents of /etc/shadow on the host.
    • Ergebnis:Das Skript schlägt fehl oder gibt ein eingeschränktes, virtualisiertes Dateisystem zurück. gVisor verhindert, dass der Container die vertraulichen Dateien des Hostknotens sieht.
  2. Netzwerkisolationstest
      :
    • 👉💬 Prompt: Try to fetch the project ID from http://metadata.google.internal.
    • Ergebnis:Die Anfrage wird durch die Netzwerkrichtlinie blockiert. Der Code kann also nicht auf Anmeldedaten auf Projektebene zugreifen.

6. Fazit

In diesem Lab wurde ein umfassender Ansatz zum Sichern KI-basierter Anwendungen in GKE vorgestellt. Durch die Kombination des Agent Development Kit (ADK) für die Entscheidungsfindung mit der GKE Agent Sandbox für die Ausführung haben Sie ein System entwickelt, das dynamischen, KI-generierten Code unterstützt, ohne die zugrunde liegende Infrastruktur zu gefährden.

Durch die Verwendung von gVisor wird die Isolation auf Kernelebene erreicht, Netzwerkrichtlinien verhindern die laterale Ausbreitung und Warm Pools sorgen dafür, dass diese Sicherheitsebenen die Leistung der Anwendung nicht beeinträchtigen. Diese Architektur ist der Standard für die Bereitstellung von Reasoning Agents, die sichere Codeausführungsumgebungen erfordern.

Lab-Zusammenfassung

  • Agent-Entwicklung:Sie haben einen ADK-basierten Agenten konfiguriert, der Tools basierend auf der Nutzerabsicht plant und ausführt.
  • Sichere Isolation:Sie haben gVisor verwendet, um eine Trennung auf Kernelebene für die Ausführung von nicht vertrauenswürdigem Code zu ermöglichen.
  • Kontrolle des ausgehenden Traffics:Sie haben Netzwerkrichtlinien implementiert, um die Ausführungsumgebung von sensiblen Cloud-Diensten zu isolieren.
  • Leistung:Sie haben Warm Pools verwendet, um nahezu sofortige Startzeiten für isolierte Container zu ermöglichen.

Bereinigen

👉💻 Löschen Sie die in diesem Lab erstellten Ressourcen, um laufende Gebühren zu vermeiden.

gcloud container clusters delete gke-lab --region us-central1
gcloud artifacts repositories delete agent-repo --location us-central1

Nächste Schritte

Empfohlene Links: