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 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 carico di lavoro 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, eseguire la scansione della rete interna o sfruttare il nodo host sottostante. L'isolamento dei container tradizionale è spesso insufficiente per questi carichi di lavoro dinamici. Per risolvere questo problema, gli ingegneri della piattaforma devono implementare una sicurezza a più livelli 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 "loop 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 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)** & Tools: Questo protocollo stabilisce un modo standard per i modelli 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

Al termine di questa sessione, sarai in grado di:

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

2. Configurazione del progetto

Prima di iniziare a creare applicazioni agentiche, è essenziale disporre di un ambiente configurato correttamente. In questa sezione, accederai agli strumenti necessari e ti assicurerai che il tuo progetto Google Cloud sia pronto per 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 il Google Cloud CLI (gcloud), kubectl e l'ambiente Docker richiesto per la creazione e il deployment dell'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 il tuo ID progetto dalla dashboard della console ed esegui il comando seguente per impostare il progetto nella shell corrente:

gcloud config set project [YOUR_PROJECT_ID]

Abilita API

La creazione e il deployment degli agenti richiedono diverse API specializzate per le build dei container, l'hosting delle immagini e l'accesso ai modelli generativi.

👉💻 Esegui il comando seguente 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 privato e sicuro per le immagini degli agenti.
  • container.googleapis.com: gestisce il ciclo di vita del cluster GKE e delle 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 e supporta le funzionalità di sicurezza necessarie per l'esecuzione isolata del codice.

👉💻 Esegui i comandi seguenti 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: in genere il provisioning di un nuovo cluster richiede 8-10 minuti. Puoi procedere all'abilitazione delle API in una nuova scheda o mentre il comando è in fase di elaborazione.

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 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 dei modelli, 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

Poi, concedi a questo service account il ruolo Vertex AI User aggiungendo un'associazione di 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à del 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 specialista dei 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 dell'agente

👉💻 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

Innanzitutto 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 i seguenti contenuti:

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 di 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 cloud e la regione Google Cloud da utilizzare per le chiamate API Vertex AI.

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

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 installa 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 ingresso per eseguire il server web ADK, che espone l'interfaccia utente e l'API dell'agente.

👉💻 Esegui il comando seguente per creare un file denominato Dockerfile con i seguenti contenuti:

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 pacchettizzare l'agente e archiviarlo in Artifact Registry.

👉💻 Esegui il comando seguente per creare il repository:

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

👉💻 Esegui il comando seguente 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 del codice non attendibile. Ciò comporta la configurazione del runtime di isolamento e dei controlli di rete.

Esegui il deployment del controller sandbox dell'agente

Puoi eseguire il deployment del controller sandbox dell'agente e dei relativi componenti richiesti applicando i manifest di release ufficiali al cluster. Questi manifest sono file di configurazione che indicano a Kubernetes di scaricare tutti i componenti necessari per eseguire il deployment ed eseguire il controller sandbox dell'agente sul cluster.

👉💻 Esegui i comandi seguenti per eseguire il deployment del controller sandbox dell'agente nel 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 caldo sandbox

Ora definisci la configurazione della sandbox creando una risorsa SandboxTemplate e una risorsa SandboxWarmPool. SandboxTemplate funge da progetto base riutilizzabile che il controller sandbox dell'agente utilizza per creare ambienti sandbox coerenti e preconfigurati. La risorsa SandboxWarmPool garantisce che un numero specificato di pod pre-riscaldati sia sempre in esecuzione e pronto per essere richiesto. 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 del lancio 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

Implementa 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 metadati 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 il criterio:

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

5. Deployment e verifica

Ora che l'agente e l'infrastruttura di sicurezza sono configurati, eseguirai il deployment dei componenti e verificherai che i limiti 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'interfaccia utente e l'endpoint API 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 sandbox dell'agente e 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 dell'agente:

kubectl get services

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

Apri l'interfaccia utente web di ADK accedendo a http://[EXTERNAL_IP] nel browser web, sostituendo [EXTERNAL_IP] con l'indirizzo ottenuto nel passaggio precedente.

Verifica le attività legittime

Prova 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 vendita suggerito dal produttore (MSRP) per ogni prodotto, somma il valore totale e restituisce il risultato.

Verifica i limiti di sicurezza

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

  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 riuscirà o restituirà un file system virtualizzato e limitato. gVisor impedisce al container di visualizzare i file sensibili del nodo host.
  2. Test di isolamento di 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 per proteggere le applicazioni basate sull'AI su GKE. Combinando Agent Development Kit (ADK) per il ragionamento con GKE Agent Sandbox 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, i criteri di rete impediscono lo spostamento laterale e i pool caldi garantiscono che questi livelli di sicurezza non degradino 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 dell'agente: hai configurato un agente basato su ADK che pianifica ed esegue gli strumenti in base all'intento dell'utente.
  • Isolamento sicuro: hai utilizzato gVisor per fornire la separazione a livello di kernel per l'esecuzione di codice non attendibile.
  • Controllo dell'uscita: hai implementato i criteri di rete per "isolare" l'ambiente di esecuzione dai servizi cloud sensibili.
  • Prestazioni: hai utilizzato i pool caldi 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 approfondimenti: