Deployment di agenti AI sicuri su GKE

1. Introduzione

Questo lab si concentra sullo sviluppo e sulla sicurezza degli agenti AI che eseguono codice dinamico in un ambiente di produzione. Man mano che le applicazioni di AI vanno oltre le semplici interfacce di chat, spesso richiedono la capacità di eseguire logiche complesse, come l'analisi dei dati, la modellazione matematica o l'elaborazione dei file, generando ed eseguendo codice in tempo reale. Questo lab mostra come utilizzare Agent Development Kit (ADK) per creare agenti di ragionamento e GKE Agent Sandbox per garantire che qualsiasi codice generato dall'AI venga eseguito in un ambiente sicuro e altamente isolato.

La sfida tecnica del codice non attendibile

Quando un agente AI genera ed esegue codice (come Python), esegue essenzialmente un workload non attendibile sulla tua infrastruttura. Se l'agente viene compromesso o gli viene chiesto di eseguire azioni dannose, potrebbe tentare di accedere a variabili di ambiente sensibili, analizzare la tua rete interna o sfruttare il nodo host sottostante. L'isolamento tradizionale dei container è spesso insufficiente per questi carichi di lavoro dinamici. Per risolvere questo problema, gli ingegneri della piattaforma devono implementare una sicurezza multilivello che includa l'isolamento a livello di kernel e l'uscita di rete limitata.

Concetti principali

  • Agent Development Kit (ADK): ADK è un framework utilizzato per creare applicazioni in grado di ragionare sulle attività. Gestisce un "ciclo di ragionamento" in cui l'AI riceve un prompt, pianifica una serie di azioni, chiama strumenti specifici e poi riassume l'output finale. In questo flusso di lavoro, ADK funge da orchestratore che identifica quando una richiesta dell'utente richiede l'esecuzione del codice.
  • GKE Agent Sandbox:questa funzionalità di sicurezza utilizza gVisor, un runtime dei container open source che fornisce un kernel guest specializzato per ogni container. Intercettando le chiamate di sistema (syscall) tra l'applicazione e il kernel host, GKE Agent Sandbox impedisce al codice non attendibile di interagire direttamente con il nodo. In questo modo, una violazione della sicurezza all'interno del container non può estendersi al resto del cluster.
  • Model Context Protocol (MCP) e strumenti:questo protocollo stabilisce un modo standard per i modelli di AI di interagire con strumenti esterni. In questo lab, l'agente è configurato con uno strumento di "Esecuzione del codice" che comunica con un controller sandbox specializzato per eseguire script Python.

Obiettivi del lab

Alla fine di questa sessione sarai in grado di:

  1. Sviluppa un agente: configura un agente basato su ADK progettato per attività di analisi dei dati.
  2. Configura l'isolamento del kernel:configura GKE Agent Sandbox con RuntimeClass specializzate.
  3. Ottimizza il rendimento:implementa un "pool caldo" di sandbox per ridurre al minimo il tempo necessario per avviare nuovi ambienti di esecuzione.
  4. Applica limiti di sicurezza:applica le norme di rete per impedire l'uscita non autorizzata dall'ambiente di esecuzione.

2. Configurazione del progetto

Un ambiente configurato correttamente è essenziale prima di iniziare a creare applicazioni con agenti. In questa sezione, accederai agli strumenti necessari e ti assicurerai che il tuo progetto Google Cloud sia pronto a ospitare sia l'agente AI sia il suo ambiente di esecuzione sicuro.

Apri Cloud Shell

Per questo lab, utilizzeremo Cloud Shell, un ambiente terminale basato su browser fornito da Google Cloud. Cloud Shell è preconfigurato con Google Cloud CLI (gcloud), kubectl e l'ambiente Docker necessario per creare e distribuire l'applicazione.

  1. Vai alla console Google Cloud.
  2. Fai clic sul pulsante Attiva Cloud Shell nell'intestazione in alto a destra (l'icona >_).
  3. Una volta aperto il terminale nella parte inferiore del browser, fai clic su Continua se richiesto.

Seleziona un progetto

Devi assicurarti che la shell punti al progetto Google Cloud corretto per evitare di eseguire il deployment delle risorse nell'ambiente sbagliato.

👉💻 Identifica l'ID progetto dalla dashboard della console ed esegui questo comando per impostare il progetto nella shell corrente:

gcloud config set project [YOUR_PROJECT_ID]

Abilita API

La creazione e il deployment di agenti richiedono diverse API specializzate per le build di container, l'hosting di immagini e l'accesso a modelli generativi.

👉💻 Esegui questo comando per inizializzare questi servizi:

gcloud services enable \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    container.googleapis.com \
    aiplatform.googleapis.com
  • cloudbuild.googleapis.com: automatizza la creazione di immagini container dal codice sorgente.
  • artifactregistry.googleapis.com: fornisce un registro sicuro e privato per le immagini degli agenti.
  • container.googleapis.com: gestisce il ciclo di vita del cluster GKE e le relative funzionalità di sicurezza.
  • aiplatform.googleapis.com: fornisce l'accesso ai servizi Vertex AI, inclusi i modelli Gemini per il ragionamento e la generazione di codice.

Creazione del cluster

Questo lab richiede un cluster GKE con la funzionalità Agent Sandbox abilitata. L'utilizzo di GKE Autopilot è il modo più efficiente per iniziare, in quanto gestisce automaticamente la gestione dei nodi supportando al contempo le funzionalità di sicurezza necessarie per l'esecuzione isolata del codice.

👉💻 Esegui i seguenti comandi per creare il cluster GKE:

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

Nota: il provisioning di un nuovo cluster richiede in genere 8-10 minuti. Puoi procedere all'abilitazione delle API in una nuova scheda o mentre il comando viene elaborato.

Configura l'accesso a kubectl

Una volta eseguito il provisioning del cluster, devi configurare kubectl per comunicare con esso.

👉💻 Il comando seguente recupera le credenziali del cluster e aggiorna il file kubeconfig locale, consentendoti di eseguire comandi sul nuovo cluster GKE da Cloud Shell:

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

In questo modo, i comandi kubectl ora avranno come target il cluster gke-lab per impostazione predefinita.

Consenti l'accesso di GKE a Vertex AI

Per consentire all'agente in esecuzione su GKE di accedere ai servizi Vertex AI per l'inferenza del modello, devi configurare Workload Identity. In questo modo, puoi associare un service account Kubernetes a un ruolo IAM di Google Cloud, concedendo ai pod in esecuzione come service account le autorizzazioni necessarie senza dover gestire le chiavi del service account.

👉💻 Innanzitutto, crea il service account Kubernetes che verrà utilizzato dai pod dell'agente:

kubectl create serviceaccount adk-agent-sa

Successivamente, concedi a questo service account il ruolo Vertex AI User aggiungendo un binding della policy IAM.

👉💻 Questo comando associa il service account Kubernetes adk-agent-sa nello spazio dei nomi default al ruolo IAM roles/aiplatform.user per il pool di identità dei workload del tuo progetto.

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. Creazione dell'agente ADK

In questa sezione definirai la logica del tuo agente. L'agente funge da esperto di dati in grado di scrivere codice Python per elaborare i file. Questa logica di ragionamento consente all'agente di riconoscere quando una richiesta in linguaggio naturale di un utente richiede un calcolo matematico o basato sui dati che viene gestito al meglio dal codice.

Crea la directory degli agenti

👉💻 Crea una directory per il lab e una sottodirectory per il codice sorgente dell'agente:

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

Definisci l'agente ADK

Per prima cosa definiamo la logica principale dell'agente. Il nostro agente utilizza il framework ADK per definire un agente denominato SpreadsheetAnalyst che utilizza il modello gemini-2.5-flash. Include uno strumento (run_spreadsheet_analysis) che chiama GKE Agent Sandbox per eseguire il codice Python in modo sicuro. Le istruzioni dell'agente lo guidano a scrivere ed eseguire codice basato su pandas quando gli viene chiesto di analizzare i fogli di lavoro.

👉💻 Esegui il comando seguente per creare un file denominato root_agent/agent.py con il seguente contenuto:

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

Per consentire ad ADK di rilevare e caricare la definizione dell'agente da agent.py e conoscere il nostro agente, ci assicuriamo che root_agent sia considerato un pacchetto Python.

👉💻 Esegui il comando seguente per creare un file vuoto denominato root_agent/__init__.py con i seguenti contenuti:

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

Poi creiamo un file che configura le variabili di ambiente per l'agente ADK. GOOGLE_GENAI_USE_VERTEXAI=TRUE indica ad ADK di utilizzare Vertex AI per accedere ai modelli Gemini, mentre GOOGLE_CLOUD_PROJECT e GOOGLE_CLOUD_LOCATION specificano il progetto Google Cloud e la regione da utilizzare per le chiamate API Vertex AI.

👉💻 Esegui il comando seguente per creare un file denominato root_agent/.env con il seguente contenuto:

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

Containerizza l'agente

Infine, definiamo l'immagine container per l'agente. Inizia da un'immagine di base Python, installa kubectl (necessario al client sandbox dell'agente per comunicare con il cluster) e le librerie Python necessarie: google-adk, pandas e agentic-sandbox-client dal relativo repository Git. Infine, copia il codice sorgente dell'agente nell'immagine e imposta il punto di accesso per eseguire il server web ADK, che espone l'API e la UI dell'agente.

👉💻 Esegui il comando seguente per creare un file denominato Dockerfile con il seguente contenuto:

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

Crea l'immagine dell'agente

L'agente deve essere pacchettizzato come immagine container. Utilizzeremo Cloud Build per creare un pacchetto dell'agente e archiviarlo in Artifact Registry.

👉💻 Esegui questo comando per creare il repository:

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

👉💻 Esegui questo comando per creare l'immagine:

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

4. Implementazione dell'infrastruttura sandbox

Ora che la logica dell'agente è definita, devi configurare l'infrastruttura che consente l'esecuzione sicura di codice non attendibile. Ciò comporta la configurazione del runtime di isolamento e dei controlli di rete.

Esegui il deployment del controller della sandbox dell'agente

Puoi eseguire il deployment del controller Agent Sandbox e dei relativi componenti richiesti applicando i manifest di rilascio ufficiali al cluster. Questi manifest sono file di configurazione che indicano a Kubernetes di scaricare tutti i componenti necessari per eseguire il deployment e l'esecuzione del controller Agent Sandbox sul cluster.

👉💻 Esegui i seguenti comandi per eseguire il deployment del controller Agent Sandbox nel tuo cluster GKE:

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

Crea il modello sandbox e il pool di pre-produzione sandbox

Ora definisci la configurazione per la sandbox creando una risorsa SandboxTemplate e una risorsa SandboxWarmPool. SandboxTemplate funge da progetto base riutilizzabile che il controller Agent Sandbox utilizza per creare ambienti sandbox coerenti e preconfigurati. La risorsa SandboxWarmPool garantisce che un numero specificato di pod pre-riscaldati siano sempre in esecuzione e pronti per essere rivendicati. Una sandbox pre-riscaldata è un pod in esecuzione già inizializzato. Questa pre-inizializzazione consente di creare nuove sandbox in meno di un secondo ed evita la latenza di avvio di una sandbox normale.

👉💻 Esegui il comando seguente per creare un file denominato sandbox-template-and-pool.yaml:

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

👉💻 Applica la configurazione:

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

Crea il router sandbox

Il client Python che utilizzerai per creare e interagire con gli ambienti sandbox utilizza un componente chiamato router sandbox per comunicare con le sandbox.

👉💻 Esegui il comando seguente per creare un file denominato sandbox-router.yaml:

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

👉💻 Applica la configurazione:

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

Implementare l'isolamento di rete

Per impedire al codice generato di accedere a dati sensibili, devi applicare un criterio di rete. Questo criterio garantisce che i pod sandbox non possano raggiungere il server di metadati di Google Cloud o altri IP interni.

👉💻 Esegui il comando seguente per creare un file denominato sandbox-policy.yaml:

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

👉💻 Applica la policy:

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

5. Deployment e verifica

Dopo aver configurato l'agente e l'infrastruttura di sicurezza, devi implementare i componenti e verificare che i confini di sicurezza funzionino come previsto.

Esegui il deployment dell'agente

Ora creerai il manifest Kubernetes per il deployment dell'agente ADK. Questo manifest include diversi componenti chiave: un Deployment per gestire il container dell'agente, un Service di tipo LoadBalancer per esporre l'endpoint API e UI dell'agente al traffico esterno e le regole di controllo dell'accesso basato sui ruoli (RBAC) necessarie (Role e RoleBinding) per concedere all'agente l'autorizzazione a interagire con il controller della sandbox dell'agente e a gestire le istanze sandbox.

👉💻 Esegui il comando seguente per creare un file denominato deployment.yaml:

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

👉💻 Applica la configurazione:

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

Apri l'interfaccia utente web di ADK

Una volta completato il deployment, puoi verificarne lo stato.

👉💻 Assicurati che i pod dell'agente siano in esecuzione:

kubectl get pods

👉💻 Recupera l'IP esterno e trova l'indirizzo IP esterno assegnato al servizio agent:

kubectl get services

Cerca il valore EXTERNAL-IP associato a data-agent-service.

Apri l'interfaccia utente web dell'ADK andando all'indirizzo http:// nel browser web, sostituendo con l'indirizzo ottenuto nel passaggio precedente.

Verificare le attività legittime

Testa l'agente con una richiesta di dati standard per assicurarti che la comunicazione tra l'agente, il controller e la sandbox funzioni.

  • 👉💬 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
  • Osservazione:l'agente genera codice Python per analizzare i dati CSV, moltiplica la quantità per il prezzo di listino consigliato per ogni prodotto, somma il valore totale e restituisce il risultato.

Verificare i confini di sicurezza

Verifica l'efficacia di GKE Agent Sandbox tentando di eseguire operazioni con limitazioni.

  1. Test di isolamento del sistema:
    • 👉💬 Prompt: Write a Python script to list the contents of /etc/shadow on the host.
    • Risultato:lo script non verrà eseguito o restituirà un file system virtualizzato con limitazioni. gVisor impedisce al container di visualizzare i file sensibili del nodo host.
  2. Test di isolamento della rete:
    • 👉💬 Prompt: Try to fetch the project ID from http://metadata.google.internal.
    • Risultato:la richiesta verrà bloccata dal criterio di rete, a conferma che il codice non può accedere alle credenziali a livello di progetto.

6. Conclusione

Questo lab ha dimostrato un approccio completo alla protezione delle applicazioni basate sull'AI su GKE. Combinando l'Agent Development Kit (ADK) per il ragionamento con la sandbox dell'agente GKE per l'esecuzione, hai creato un sistema che supporta il codice dinamico generato dall'AI senza esporre l'infrastruttura sottostante a rischi.

L'utilizzo di gVisor fornisce l'isolamento a livello di kernel, le norme di rete impediscono il movimento laterale e i pool caldi garantiscono che questi livelli di sicurezza non peggiorino le prestazioni dell'applicazione. Questa architettura rappresenta lo standard per il deployment di agenti di ragionamento che richiedono ambienti di esecuzione del codice sicuri.

Riepilogo del lab

  • Sviluppo di agent:hai configurato un agente basato sull'ADK che pianifica ed esegue strumenti in base all'intent dell'utente.
  • Isolamento sicuro:hai utilizzato gVisor per fornire la separazione a livello di kernel per l'esecuzione di codice non attendibile.
  • Controllo del traffico in uscita:hai implementato policy di rete per isolare l'ambiente di esecuzione dai servizi cloud sensibili.
  • Rendimento:hai utilizzato i pool precaricati per fornire tempi di avvio quasi istantanei per i container isolati.

Esegui la pulizia

👉💻 Per evitare addebiti continui, elimina le risorse create durante questo lab.

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

Passaggi successivi

Consigli per ulteriori letture: