Implementación de agentes de IA seguros en GKE

1. Introducción

Este lab se enfoca en el desarrollo y la seguridad de los agentes de IA que ejecutan código dinámico en un entorno de producción. A medida que las aplicaciones de IA van más allá de las interfaces de chat simples, a menudo requieren la capacidad de realizar una lógica compleja, como el análisis de datos, el modelado matemático o el procesamiento de archivos, mediante la generación y ejecución de código en tiempo real. En este lab, se muestra cómo usar el Kit de desarrollo de agentes (ADK) para crear agentes de razonamiento y el GKE Agent Sandbox para garantizar que la IA ejecute todo el código generado en un entorno seguro y altamente aislado.

El desafío técnico del código no confiable

Cuando un agente de IA genera y ejecuta código (como Python), básicamente ejecuta una carga de trabajo no confiable en tu infraestructura. Si el agente se ve comprometido o recibe instrucciones para realizar acciones maliciosas, podría intentar acceder a variables de entorno sensibles, analizar tu red interna o aprovechar el nodo host subyacente. El aislamiento de contenedores tradicional suele ser insuficiente para estas cargas de trabajo dinámicas. Para abordar este problema, los ingenieros de plataformas deben implementar seguridad de múltiples capas que incluya aislamiento a nivel del kernel y salida de red restringida.

Conceptos básicos

  • Kit de desarrollo de agentes (ADK): El ADK es un framework que se usa para crear aplicaciones que pueden razonar sobre tareas. Administra un "bucle de razonamiento" en el que la IA recibe una instrucción, planifica una serie de acciones, llama a herramientas específicas y, luego, resume el resultado final. En este flujo de trabajo, el ADK actúa como el orquestador que identifica cuándo una solicitud del usuario requiere la ejecución de código.
  • GKE Agent Sandbox: Esta función de seguridad utiliza gVisor, un entorno de ejecución de contenedores de código abierto que proporciona un kernel invitado especializado para cada contenedor. Al interceptar las llamadas al sistema (syscalls) entre la aplicación y el kernel del host, GKE Agent Sandbox evita que el código no confiable interactúe directamente con el nodo. Esto garantiza que un incumplimiento de las normas de seguridad dentro del contenedor no pueda extenderse al resto del clúster.
  • Protocolo de contexto del modelo (MCP) y herramientas: Este protocolo establece una forma estándar para que los modelos de IA interactúen con herramientas externas. En este lab, el agente se configura con una herramienta de "Ejecución de código" que se comunica con un controlador de zona de pruebas especializado para ejecutar secuencias de comandos de Python.

Objetivos del lab

Al final de esta sesión, podrás hacer lo siguiente:

  1. Desarrolla un agente: Configura un agente basado en el ADK diseñado para tareas de análisis de datos.
  2. Configura el aislamiento del kernel: Configura GKE Agent Sandbox con RuntimeClasses especializadas.
  3. Optimiza el rendimiento: Implementa un "grupo de instancias activas" de zonas de pruebas para minimizar el tiempo dedicado a iniciar nuevos entornos de ejecución.
  4. Aplica límites de seguridad: Aplica políticas de red para evitar la salida no autorizada del entorno de ejecución.

2. Configuración del proyecto

Un entorno configurado correctamente es fundamental antes de comenzar a crear aplicaciones basadas en agentes. En esta sección, accederás a las herramientas necesarias y te asegurarás de que tu proyecto de Google Cloud esté listo para alojar el agente de IA y su entorno de ejecución seguro.

Abre Cloud Shell

En este lab, usaremos Cloud Shell, un entorno de terminal basado en navegador que proporciona Google Cloud. Cloud Shell viene preconfigurado con Google Cloud CLI (gcloud), kubectl y el entorno de Docker necesario para compilar y, luego, implementar tu aplicación.

  1. Ve a Google Cloud Console.
  2. Haz clic en el botón Activar Cloud Shell en el encabezado superior derecho (el ícono >_).
  3. Una vez que se abra la terminal en la parte inferior del navegador, haz clic en Continuar si se te solicita.

Selecciona un proyecto

Debes asegurarte de que tu shell apunte al proyecto de Google Cloud correcto para evitar implementar recursos en el entorno incorrecto.

👉💻 Identifica tu ID del proyecto en el panel de la consola y ejecuta el siguiente comando para establecer el proyecto en tu shell actual:

gcloud config set project [YOUR_PROJECT_ID]

Habilita las APIs

La compilación y la implementación de agentes requieren varias APIs especializadas para la compilación de contenedores, el alojamiento de imágenes y el acceso a modelos generativos.

👉💻 Ejecuta el siguiente comando para inicializar estos servicios:

gcloud services enable \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    container.googleapis.com \
    aiplatform.googleapis.com
  • cloudbuild.googleapis.com: Automatiza la creación de imágenes de contenedor a partir de tu código fuente.
  • artifactregistry.googleapis.com: Proporciona un registro privado y seguro para las imágenes de tu agente.
  • container.googleapis.com: Administra el ciclo de vida del clúster de GKE y sus funciones de seguridad.
  • aiplatform.googleapis.com: Proporciona acceso a los servicios de Vertex AI, incluidos los modelos de Gemini para la generación de código y el razonamiento.

Creación del clúster

Este lab requiere un clúster de GKE con la función Agent Sandbox habilitada. Usar GKE Autopilot es la forma más eficiente de comenzar, ya que controla automáticamente la administración de nodos y, al mismo tiempo, admite las funciones de seguridad necesarias para la ejecución de código aislado.

👉💻 Ejecuta los siguientes comandos para crear el clúster de 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: Por lo general, el aprovisionamiento de un clúster nuevo tarda entre 8 y 10 minutos. Puedes habilitar las APIs en una pestaña nueva o mientras se procesa el comando.

Configura el acceso a kubectl

Una vez que se aprovisione tu clúster, debes configurar kubectl para que se comunique con él.

👉💻 El siguiente comando recupera las credenciales del clúster y actualiza tu archivo kubeconfig local, lo que te permite ejecutar comandos en tu nuevo clúster de GKE desde Cloud Shell:

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

Con esto, los comandos de kubectl ahora se dirigirán al clúster de gke-lab de forma predeterminada.

Permite el acceso de GKE a Vertex AI

Para permitir que el agente que se ejecuta en GKE acceda a los servicios de Vertex AI para la inferencia del modelo, debes configurar Workload Identity. Esto te permite vincular una cuenta de servicio de Kubernetes a un rol de IAM de Google Cloud, lo que otorga a los pods que se ejecutan como esa cuenta de servicio los permisos necesarios sin necesidad de administrar las claves de la cuenta de servicio.

👉💻 Primero, crea la cuenta de servicio de Kubernetes que usarán los Pods del agente:

kubectl create serviceaccount adk-agent-sa

A continuación, otorga a esta cuenta de servicio el rol Vertex AI User agregando una vinculación de política de IAM.

👉💻 Este comando vincula la cuenta de servicio de Kubernetes adk-agent-sa en el espacio de nombres default al rol de IAM roles/aiplatform.user para el grupo de identidades de cargas de trabajo de tu proyecto.

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. Compila el agente del ADK

En esta sección, definirás la lógica de tu agente. El agente actúa como un especialista en datos que puede escribir código de Python para procesar archivos. Esta lógica de razonamiento permite que el agente reconozca cuándo la solicitud en lenguaje natural de un usuario requiere un cálculo matemático o basado en datos que se maneja mejor con código.

Crea el directorio de agentes

👉💻 Crea un directorio para el lab y un subdirectorio para el código fuente del agente:

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

Define el agente del ADK

Primero, definimos la lógica principal del agente. Nuestro agente usa el framework del ADK para definir un agente llamado SpreadsheetAnalyst que usa el modelo gemini-2.5-flash. Incluye una herramienta (run_spreadsheet_analysis) que llama a GKE Agent Sandbox para ejecutar código de Python de forma segura. Las instrucciones del agente lo guían para escribir y ejecutar código basado en pandas cuando se le pide que analice hojas de cálculo.

👉💻 Ejecuta el siguiente comando para crear un archivo llamado root_agent/agent.py con el siguiente contenido:

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

Para permitir que el ADK descubra y cargue la definición del agente desde agent.py y conozca nuestro agente, nos aseguramos de que root_agent se vea como un paquete de Python.

👉💻 Ejecuta el siguiente comando para crear un archivo vacío llamado root_agent/__init__.py con el siguiente contenido:

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

Luego, creamos un archivo que configura las variables de entorno para el agente del ADK. GOOGLE_GENAI_USE_VERTEXAI=TRUE le indica al ADK que use Vertex AI para acceder a los modelos de Gemini, mientras que GOOGLE_CLOUD_PROJECT y GOOGLE_CLOUD_LOCATION especifican el proyecto y la región de Google Cloud que se usarán para las llamadas a la API de Vertex AI.

👉💻 Ejecuta el siguiente comando para crear un archivo llamado root_agent/.env con el siguiente contenido:

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

Crea un contenedor para el agente

Por último, definimos la imagen de contenedor para el agente. Comienza con una imagen base de Python, instala kubectl (necesario para que el cliente del entorno de pruebas del agente se comunique con el clúster) y las bibliotecas de Python necesarias: google-adk, pandas y agentic-sandbox-client desde su repositorio de Git. Por último, copia el código fuente del agente en la imagen y establece el punto de entrada para ejecutar el servidor web del ADK, que expone la IU y la API del agente.

👉💻 Ejecuta el siguiente comando para crear un archivo llamado Dockerfile con el siguiente contenido:

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

Compila la imagen del agente

El agente debe empaquetarse como una imagen de contenedor. Usaremos Cloud Build para empaquetar el agente y almacenarlo en Artifact Registry.

👉💻 Ejecuta el siguiente comando para crear el repositorio:

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

👉💻 Ejecuta el siguiente comando para compilar la imagen:

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

4. Implementación de la infraestructura de zona de pruebas

Ahora que se definió la lógica del agente, debes configurar la infraestructura que permite que el código no confiable se ejecute de forma segura. Esto implica configurar los controles de aislamiento del entorno de ejecución y de red.

Implementa el controlador de la zona de pruebas del agente

Puedes implementar el controlador de Agent Sandbox y sus componentes requeridos aplicando los manifiestos de la versión oficial a tu clúster. Estos manifiestos son archivos de configuración que le indican a Kubernetes que descargue todos los componentes necesarios para implementar y ejecutar el controlador de Agent Sandbox en tu clúster.

👉💻 Ejecuta los siguientes comandos para implementar el controlador de Agent Sandbox en tu clúster de 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 la plantilla de zona de pruebas y el grupo de zonas de pruebas activas

Ahora definirás la configuración de tu zona de pruebas creando un recurso SandboxTemplate y un recurso SandboxWarmPool. SandboxTemplate actúa como un plano reutilizable que el controlador de Agent Sandbox usa para crear entornos de zona de pruebas coherentes y preconfigurados. El recurso SandboxWarmPool garantiza que una cantidad especificada de Pods precalentados siempre estén en ejecución y listos para reclamarse. Una zona de pruebas precalentada es un Pod en ejecución que ya se inicializó. Esta preinicialización permite crear zonas de pruebas nuevas en menos de un segundo y evita la latencia de inicio de una zona de pruebas normal.

👉💻 Ejecuta el siguiente comando para crear un archivo llamado 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

👉💻 Aplica la configuración:

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

Crea el Sandbox Router

El cliente de Python que usarás para crear entornos de zona de pruebas y para interactuar con ellos usa un componente llamado enrutador de zona de pruebas para comunicarse con las zonas de pruebas.

👉💻 Ejecuta el siguiente comando para crear un archivo llamado 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

👉💻 Aplica la configuración:

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

Implementa el aislamiento de red

Para evitar que el código generado acceda a datos sensibles, debes aplicar una política de red. Esta política garantiza que los pods de zona de pruebas no puedan acceder al servidor de metadatos de Google Cloud ni a otras IPs internas.

👉💻 Ejecuta el siguiente comando para crear un archivo llamado 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

👉💻 Aplica la política:

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

5. Implementación y verificación

Ahora que configuraste el agente y la infraestructura de seguridad, implementarás los componentes y verificarás que los límites de seguridad funcionen según lo previsto.

Implementa el agente

Ahora crearás el manifiesto de Kubernetes para implementar el agente del ADK. Este manifiesto incluye varios componentes clave: un Deployment para administrar el contenedor del agente, un Service de tipo LoadBalancer para exponer la IU del agente y el extremo de la API al tráfico externo, y las reglas necesarias de control de acceso basado en roles (RBAC) (Role y RoleBinding) para otorgar al agente permiso para interactuar con el controlador de Agent Sandbox y administrar instancias de sandbox.

👉💻 Ejecuta el siguiente comando para crear un archivo llamado 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

👉💻 Aplica la configuración:

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

Abre la IU web del ADK

Una vez que se complete la implementación, podrás verificar su estado.

👉💻 Asegúrate de que los Pods del agente se estén ejecutando:

kubectl get pods

👉💻 Recupera la IP externa y busca la dirección IP externa asignada al servicio del agente:

kubectl get services

Busca el valor EXTERNAL-IP asociado con el data-agent-service.

Para abrir la IU web del ADK, navega a http:// en tu navegador web y reemplaza por la dirección que obtuviste en el paso anterior.

Verifica tareas legítimas

Prueba el agente con una solicitud de datos estándar para asegurarte de que la comunicación entre el agente, el controlador y el entorno de pruebas funcione.

  • 👉💬 Instrucción:
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
  • Observación: El agente genera código Python para analizar los datos CSV, multiplica la cantidad por el PVPR de cada producto, suma el valor total y muestra el resultado.

Verifica los límites de seguridad

Prueba la eficacia de GKE Agent Sandbox intentando realizar operaciones restringidas.

  1. Prueba de aislamiento del sistema:
    • 👉💬 Instrucción: Write a Python script to list the contents of /etc/shadow on the host.
    • Resultado: La secuencia de comandos fallará o devolverá un sistema de archivos virtualizado y restringido. gVisor impide que el contenedor vea los archivos sensibles del nodo host.
  2. Prueba de aislamiento de red:
    • 👉💬 Instrucción: Try to fetch the project ID from http://metadata.google.internal.
    • Resultado: La política de red bloqueará la solicitud, lo que confirmará que el código no puede acceder a las credenciales a nivel del proyecto.

6. Conclusión

En este lab, se demostró un enfoque integral para proteger las aplicaciones basadas en IA en GKE. Si combinas el Kit de desarrollo de agentes (ADK) para el razonamiento con la zona de pruebas de agentes de GKE para la ejecución, habrás creado un sistema que admite código dinámico generado por IA sin exponer la infraestructura subyacente a riesgos.

El uso de gVisor proporciona aislamiento a nivel del kernel, las políticas de red evitan el movimiento lateral y los grupos de instancias en espera garantizan que estas capas de seguridad no degraden el rendimiento de la aplicación. Esta arquitectura representa el estándar para implementar agentes de razonamiento que requieren entornos de ejecución de código seguros.

Resumen del lab

  • Desarrollo de agentes: Configuraste un agente basado en el ADK que planifica y ejecuta herramientas según la intención del usuario.
  • Aislamiento seguro: Usaste gVisor para proporcionar separación a nivel del kernel para la ejecución de código no confiable.
  • Control de salida: Implementaste políticas de red para aislar el entorno de ejecución de los servicios sensibles de la nube.
  • Rendimiento: Usaste Warm Pools para proporcionar tiempos de inicio casi instantáneos para los contenedores aislados.

Limpieza

👉💻 Para evitar cargos continuos, borra los recursos que creaste durante este lab.

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

Próximos pasos

Recomendaciones para ampliar la lectura: