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 dentro de 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 la 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 GKE Agent Sandbox para garantizar que cualquier código generado por la IA se ejecute 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 se le indica que realice 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 la plataforma deben implementar seguridad de varias 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 compilar aplicaciones que pueden razonar sobre las tareas. Administra un "bucle de razonamiento" en el que la IA recibe un mensaje, 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 del sistema (syscalls) entre la aplicación y el kernel host, GKE Agent Sandbox evita que el código no confiable interactúe directamente con el nodo. Esto garantiza que una violación de la seguridad dentro del contenedor no pueda propagarse 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. Desarrollar un agente: Configurar un agente basado en ADK diseñado para tareas de análisis de datos
  2. Configurar el aislamiento del kernel: Configurar GKE Agent Sandbox con RuntimeClasses especializadas
  3. Optimizar el rendimiento: Implementar un "grupo de nodos semicalientes" de zonas de pruebas para minimizar el tiempo que se tarda en iniciar entornos de ejecución nuevos
  4. Aplicar límites de seguridad: Aplicar 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 esencial antes de comenzar a compilar aplicaciones de 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

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

  1. Ve a la consola de Google Cloud.
  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 configurar 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 compilaciones de contenedores, alojamiento de imágenes y 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 seguro y privado 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 el razonamiento y la generación de código.

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 mientras 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: El aprovisionamiento de un clúster nuevo suele tardar entre 8 y 10 minutos. Puedes continuar para habilitar las APIs en una pestaña nueva o mientras se procesa el comando.

Configura el acceso a kubectl

Una vez que se aprovisiona el 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 kubectl ahora se orientarán al clúster gke-lab de forma predeterminada.

Permite que GKE acceda a Vertex AI

Para permitir que el agente que se ejecuta en GKE acceda a los servicios de Vertex AI para la inferencia de modelos, debes configurar Workload Identity. Esto te permite vincular una cuenta de servicio de Kubernetes a un rol de Cloud 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 para 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 una 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 del agente

👉💻 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, definiremos la lógica central 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 solicita 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, y 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

Aloja el agente en contenedores

Por último, definimos la imagen de contenedor para el agente. Comienza con una imagen base de Python, instala kubectl (necesario para que el cliente de la zona 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. Implementa la infraestructura de la zona de pruebas

Ahora que se define 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 el entorno de ejecución de aislamiento y los controles de red.

Implementa el controlador de la zona de pruebas del agente

Puedes implementar el controlador de la zona de pruebas del agente y sus componentes necesarios 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 la zona de pruebas del agente en tu clúster.

👉💻 Ejecuta los siguientes comandos para implementar el controlador de la zona de pruebas del agente 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 la zona de pruebas y el grupo de nodos semicalientes de la zona de pruebas

Ahora definirás la configuración de tu zona de pruebas creando un SandboxTemplate y un recurso SandboxWarmPool. SandboxTemplate actúa como un plano reutilizable que el controlador de la zona de pruebas del agente usa para crear entornos de zona de pruebas coherentes y preconfigurados. El recurso SandboxWarmPool garantiza que una cantidad especificada de pods semicalientes siempre se ejecuten y estén listos para reclamarse. Una zona de pruebas semicaliente es un pod en ejecución que ya se inicializó. Esta inicialización previa 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 de:

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

Crea el router de la zona de pruebas

El cliente de Python que usarás para crear entornos de zona de pruebas y para interactuar con ellos usa un componente llamado router de la 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 de:

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 la zona de pruebas no puedan llegar 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

Con el agente y la infraestructura de seguridad configurados, ahora implementarás los componentes y verificarás que los límites de seguridad funcionen como se espera.

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 y el extremo de la API del agente 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 la zona de pruebas del agente y administrar instancias de la zona de pruebas.

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

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

Abre la IU web del ADK

Una vez que se complete la implementación, puedes verificar su estado.

👉💻 Asegúrate de que los pods del agente estén en ejecución:

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 data-agent-service.

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

Verifica las 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 la zona de pruebas funcione.

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

Verifica los límites de seguridad

Para probar la eficacia de GKE Agent Sandbox, intenta realizar operaciones restringidas.

  1. Prueba de aislamiento del sistema:
    • 👉💬 Prompt: Write a Python script to list the contents of /etc/shadow on the host.
    • Resultado: La secuencia de comandos fallará o mostrará un sistema de archivos virtualizado y restringido. gVisor evita que el contenedor vea los archivos sensibles del nodo host.
  2. Prueba de aislamiento de red:
    • 👉💬 Prompt: Try to fetch the project ID from http://metadata.google.internal.
    • Resultado: La política de red bloqueará la solicitud, lo que confirma 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 GKE Agent Sandbox para la ejecución, creaste un sistema que admite código dinámico generado por IA sin exponer la infraestructura subyacente al riesgo.

El uso de gVisor proporciona aislamiento a nivel del kernel, las políticas de red evitan el movimiento lateral y los grupos de nodos semicalientes 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 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 grupos de nodos semicalientes para proporcionar tiempos de inicio casi instantáneos para contenedores aislados.

Limpieza

👉💻 Para evitar cargos continuos, borra los recursos creados 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 tus conocimientos: