Implementa una aplicación de IA con agentes en GKE con el Kit de desarrollo de agentes (ADK) y Vertex AI

Estándar

---

En esta guía, se muestra cómo implementar y administrar aplicaciones de IA/ML basadas en agentes y alojadas en contenedores con Google Kubernetes Engine (GKE). Si combinas el Kit de desarrollo de agentes (ADK) de Google con Vertex AI como proveedor de modelos de lenguaje grandes (LLM), puedes poner en funcionamiento agentes de IA de manera eficiente y a gran escala. En esta guía, se explica el proceso integral para llevar un agente basado en FastAPI y potenciado por Gemini 2.0 Flash desde el desarrollo hasta la implementación en producción en GKE.

Esta guía está dirigida a ingenieros de aprendizaje automático (AA), desarrolladores y arquitectos de nube interesados en usar las capacidades de organización de contenedores de Kubernetes para entregar aplicaciones de IA/ML basadas en agentes. Para obtener más información sobre los roles comunes y las tareas de ejemplo en el contenido de Google Cloud , consulta Roles de usuario y tareas comunes de GKE Enterprise.

Antes de comenzar, asegúrate de conocer la siguiente información:

• GKE
• Creación de contenedores con Docker
• Vertex AI

Fondo

En esta guía, se combinan varias tecnologías de Google para crear una plataforma escalable para la IA basada en agentes. GKE proporciona la orquestación de contenedores para el agente, que se compila con el ADK. Cuando se usa la API de Vertex AI para la inferencia de LLM, el clúster de GKE no requiere hardware de GPU especializado, ya que la infraestructura administrada de Google controla la inferencia.

Kit de desarrollo de agentes (ADK) de Google

El Kit de desarrollo de agentes (ADK) es un framework flexible y modular para desarrollar y, luego, implementar agentes de IA. Aunque está optimizado para Gemini y el ecosistema de Google, el ADK es independiente del modelo y de la implementación, y se creó para ser compatible con otros frameworks.

Para obtener más información, consulta la documentación del ADK.

Servicio de Kubernetes administrado por GKE

GKE es un servicio administrado de Kubernetes para implementar, escalar y administrar aplicaciones en contenedores. GKE proporciona la infraestructura necesaria, incluidos los recursos escalables, la computación distribuida y las redes eficientes, para controlar las demandas computacionales de los LLM.

Para obtener más información sobre los conceptos clave de Kubernetes, consulta Comienza a aprender sobre Kubernetes. Para obtener más información sobre GKE y cómo te ayuda a escalar, automatizar y administrar Kubernetes, consulta la Descripción general de GKE.

Vertex AI

Vertex AI es la plataforma unificada de AA de Google Cloud, que permite a los desarrolladores compilar, implementar y escalar modelos de IA/AA. Para las aplicaciones de IA basadas en agentes en GKE, Vertex AI proporciona herramientas y servicios esenciales, incluido el acceso a LLMs como Gemini 2.0 Flash, infraestructura administrada para el entrenamiento y la inferencia, y capacidades de MLOps para una administración eficiente del ciclo de vida.

Cuando se consumen LLMs a través de la API de Vertex AI, la inferencia del modelo se produce en la infraestructura administrada de Google, lo que reduce la necesidad de cuotas específicas de GPU o TPU en tu clúster de GKE.

Para obtener más información sobre Vertex AI para aplicaciones de IA basadas en agentes, consulta la documentación de Vertex AI.

Gemini 2.0 Flash

Gemini 2.0 Flash ofrece funciones de nueva generación y capacidades mejoradas diseñadas para cargas de trabajo basadas en agentes, como mayor velocidad, uso de herramientas integrado, generación multimodal y una ventana de contexto de 1 millón de tokens. Gemini 2.0 Flash mejora el modelo Flash anterior y ofrece una calidad mejorada a velocidades similares.

Para obtener información técnica sobre Gemini 2.0 Flash (como criterios de referencia de rendimiento, información sobre nuestros conjuntos de datos de entrenamiento, iniciativas de sostenibilidad, uso previsto y limitaciones, y nuestro enfoque sobre ética y seguridad), consulta la tarjeta del modelo de Gemini 2.0 Flash.

Objetivos

Esta guía te muestra cómo hacer lo siguiente:

• Configura tu entorno de Google Cloud .
• Compila una imagen de contenedor para tu agente.
• Implementa el agente en un clúster de GKE.
• Prueba el agente implementado.

Costos

En esta guía, se usan los siguientes componentes facturables de Google Cloud:

• GKE
• Artifact Registry
• Cloud Build
• Vertex AI

Revisa los precios de cada servicio para comprender los costos potenciales.

Antes de comenzar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

• Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin, roles/artifactregistry.admin, roles/cloudbuild.builds.editor, roles/resourcemanager.projectIamAdmin

  Check for the roles

  1. In the Google Cloud console, go to the IAM page.

     Go to IAM
  2. Select the project.

  3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

  4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

  Grant the roles

  1. In the Google Cloud console, go to the IAM page.

     Ir a IAM
  2. Selecciona el proyecto.
  3. Haz clic en Otorgar acceso.

  4. En el campo Principales nuevas, ingresa tu identificador de usuario. Esta suele ser la dirección de correo electrónico de una Cuenta de Google.

  5. En la lista Seleccionar un rol, elige uno.
  6. Para otorgar roles adicionales, haz clic en Agregar otro rol y agrega uno más.
  7. Haz clic en Guardar.

  Prepare el entorno

  En este instructivo, se usa Cloud Shell para administrar recursos alojados en Google Cloud. Cloud Shell viene preinstalado con el software que necesitas para este instructivo, incluidos kubectl, terraform y Google Cloud CLI.

  Para configurar tu entorno con Cloud Shell, sigue estos pasos:

  1. En la Google Cloud consola, inicia una sesión de Cloud Shell y haz clic en Activar Cloud Shell. Esta acción inicia una sesión en el panel inferior de la consola de Google Cloud .

  2. Configura las variables de entorno predeterminadas:

     gcloud config set project PROJECT_ID
     export GOOGLE_CLOUD_LOCATION=REGION
     export PROJECT_ID=PROJECT_ID
     export GOOGLE_CLOUD_PROJECT=$PROJECT_ID
     export WORKLOAD_POOL=$PROJECT_ID.svc.id.goog
     export PROJECT_NUMBER=$(gcloud projects describe --format json $PROJECT_ID | jq -r ".projectNumber")
     

     Reemplaza los siguientes valores:

     • PROJECT_ID: El Google Cloud ID del proyecto.
     • REGION: La Google Cloud región (por ejemplo, us-central1) para aprovisionar tu clúster de GKE, Artifact Registry y otros recursos regionales.

  Clona el proyecto de ejemplo

  1. Desde la terminal de Cloud Shell, clona el repositorio de código de muestra del instructivo:

     git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
     

  2. Navega hacia el directorio del instructivo:

     cd kubernetes-engine-samples/ai-ml/adk-vertex
     

  Crea y configura recursos de Google Cloud

  Para implementar tu agente en GKE, aprovisiona los recursosGoogle Cloud necesarios. Puedes implementar el agente con gcloud CLI para la ejecución directa desde la línea de comandos o con Terraform para la infraestructura como código.

  gcloud

  En esta sección, se proporcionan comandos de gcloud CLI para configurar tu clúster de GKE, Artifact Registry y Workload Identity Federation for GKE para una integración perfecta con Vertex AI. Asegúrate de haber configurado las variables de entorno como se describe en Prepara el entorno.

  1. Crea un clúster de GKE: Puedes implementar tu aplicación basada en agentes alojada en contenedores en un clúster de GKE Autopilot o Standard. Usa un clúster de Autopilot para una experiencia de Kubernetes completamente administrada. Para elegir el modo de operación de GKE que mejor se adapte a tus cargas de trabajo, consulta Elige un modo de operación de GKE.

     Autopilot

     En Cloud Shell, ejecute el siguiente comando:

     gcloud container clusters create-auto CLUSTER_NAME \
             --location=$GOOGLE_CLOUD_LOCATION \
             --project=$PROJECT_ID
     

     Reemplaza CLUSTER_NAME por el nombre de tu clúster de GKE Autopilot.

     Estándar

     En Cloud Shell, ejecute el siguiente comando:

     gcloud container clusters create CLUSTER_NAME \
         --location=$GOOGLE_CLOUD_LOCATION \
         --project=$PROJECT_ID \
         --release-channel=stable \
         --num-nodes=1 \
         --machine-type=e2-medium \
         --workload-pool=$PROJECT_ID.svc.id.goog
     

     Reemplaza CLUSTER_NAME por el nombre de tu clúster Standard.

  2. Crea un repositorio de Artifact Registry para tu contenedor de Docker: Crea un repositorio de Artifact Registry para almacenar y administrar de forma segura la imagen del contenedor de Docker de tu agente. Este registro privado ayuda a garantizar que tu aplicación esté disponible para implementarse en GKE y se integra con Cloud Build.

     gcloud artifacts repositories create adk-repo \
         --repository-format=docker \
         --location=$GOOGLE_CLOUD_LOCATION \
         --project=$PROJECT_ID
     

  3. Obtén la URL del repositorio: Ejecuta este comando para verificar la ruta completa a tu repositorio. Usarás este formato de ruta de acceso para etiquetar tu imagen de Docker en el siguiente paso.

     gcloud artifacts repositories describe adk-repo \
         --location $GOOGLE_CLOUD_LOCATION \
         --project=$PROJECT_ID
     

  4. Otorga a la cuenta de servicio predeterminada de Compute Engine los roles de IAM necesarios: De forma predeterminada, la cuenta de servicio predeterminada de Compute Engine no tiene permisos para enviar imágenes a Artifact Registry ni para ver objetos en Cloud Storage o registros. Otorga los roles necesarios para estas operaciones.

     ROLES_TO_ASSIGN=(
         "roles/artifactregistry.writer"
         "roles/storage.objectViewer"
         "roles/logging.viewer"
     )
     
     for ROLE in "${ROLES_TO_ASSIGN[@]}"; do
         gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
             --member="serviceAccount:${PROJECT_NUMBER}[e-mail]" \
             --role="${ROLE}"
     done
     

  5. Compila y envía la imagen del contenedor del agente: Ejecuta este comando para compilar tu imagen de Docker y enviarla a tu registro de Artifact Registry. Asegúrate de que el Dockerfile y el código de la aplicación estén dentro del directorio /app.

     export IMAGE_URL="${GOOGLE_CLOUD_LOCATION}-docker.pkg.dev/${PROJECT_ID}/adk-repo/adk-agent:latest"
     
     gcloud builds submit \
         --tag "$IMAGE_URL" \
         --project="$PROJECT_ID" \
         app
     

  6. Verifica que se haya enviado la imagen:

     gcloud artifacts docker images list \
         $GOOGLE_CLOUD_LOCATION-docker.pkg.dev/$PROJECT_ID/adk-repo/adk-agent \
         --project=$PROJECT_ID
     

  Terraform

  En esta sección, se describe cómo usar Terraform para aprovisionar tus recursos de Google Cloud. El repositorio de muestra que clonaste incluye los archivos de configuración de Terraform necesarios.

  Nota: Si usas Terraform, asegúrate de especificar el valor de REGION en el archivo default_env.tfvars.

  1. Inicializa Terraform: Navega al directorio terraform y, luego, inicializa Terraform.

     terraform init
     

  2. Revisa el plan de ejecución: Este comando muestra los cambios en la infraestructura que realizará Terraform.

     terraform plan -var-file=default_env.tfvars
     

  3. Aplica la configuración: Ejecuta el plan de Terraform para crear los recursos en tu proyecto de Google Cloud . Confirma con yes cuando se te solicite.

     terraform apply -var-file=default_env.tfvars
     

     Después de ejecutar estos comandos, Terraform aprovisiona tu clúster de GKE y tu repositorio de Artifact Registry, y configura los roles de IAM y las cuentas de servicio necesarios, incluida la federación de identidades para cargas de trabajo para GKE.

  Si deseas obtener más información sobre el uso de Terraform, consulta Compatibilidad con Terraform para GKE.

  Configura kubectl para comunicarse con tu clúster

  Si no configuraste kubectl para comunicarse con tu clúster, ejecuta el siguiente comando:

  gcloud container clusters get-credentials CLUSTER_NAME \
      --location=${GOOGLE_CLOUD_LOCATION}
  

  Reemplaza CLUSTER_NAME por el nombre de tu clúster de GKE.

  Configura la federación de identidades para cargas de trabajo para el acceso a GKE

  Puedes omitir este paso si usas Terraform. Este proceso vincula una cuenta de servicio de Kubernetes (KSA) a una cuenta de servicio de IAM para otorgar de forma segura acceso a tu agente a los servicios de Google Cloud .

  1. Crea una cuenta de servicio para acceder a Vertex AI:

     gcloud iam service-accounts create vertex-sa \
         --project=$PROJECT_ID
     

  2. Otorga a la cuenta de servicio el rol aiplatform.user. Esto permite que la cuenta de servicio interactúe con Vertex AI.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:vertex-sa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/aiplatform.user"
     

  3. Crea un KSA en tu clúster. Asegúrate de seguir las instrucciones en Configura kubectl para comunicarse con tu clúster antes de ejecutar este comando.

     kubectl create serviceaccount vertex-sa
     

  4. Anota la KSA para vincularla a tu cuenta de servicio:

     kubectl annotate serviceaccount vertex-sa \
         iam.gke.io/gcp-service-account=vertex-sa@$PROJECT_ID.iam.gserviceaccount.com
     

  5. Otorga a tu cuenta de servicio permisos para actuar como usuario de la federación de identidades para cargas de trabajo de GKE para la KSA:

     gcloud iam service-accounts add-iam-policy-binding vertex-sa@$PROJECT_ID.iam.gserviceaccount.com \
         --role roles/iam.workloadIdentityUser \
         --member "serviceAccount:$PROJECT_ID.svc.id.goog[default/vertex-sa]"
     

  Implementa y configura la aplicación del agente

  Después de configurar tus recursos de Google Cloud , prepara tu aplicación de agente para la implementación y configura su entorno de ejecución en GKE. Esto implica definir el código de tu agente, crear un Dockerfile para alojarlo en un contenedor y escribir un manifiesto de Kubernetes para implementarlo en tu clúster.

  1. Comprende la estructura de la aplicación del agente: El directorio /app contiene los archivos principales de la aplicación del agente:
     • main.py: Es el punto de entrada de la aplicación FastAPI, responsable de exponer la API del agente.
     • agent.py: Contiene la lógica del agente del ADK, que define cómo usa Vertex AI y controla las solicitudes.
     • __init__.py: Inicializa el paquete de Python.
     • requirements.txt: Muestra todas las dependencias de Python para tu agente.
     • Dockerfile: Define cómo se empaqueta tu aplicación en una imagen de Docker.

  2. Crea el manifiesto de implementación del agente: En el directorio tutorials-and-examples/adk/vertex, crea el siguiente manifiesto como un archivo llamado agent-deployment.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: adk-agent-deployment
       labels:
         app: adk-agent
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: adk-agent
       template:
         metadata:
           labels:
             app: adk-agent
         spec:
           serviceAccountName: vertex-sa
           containers:
           - name: adk-agent
             image: IMAGE_URL
             ports:
             - containerPort: 8000
             env:
             - name: GOOGLE_CLOUD_PROJECT_ID
               value: PROJECT_ID
             - name: GOOGLE_CLOUD_LOCATION
               value: REGION
             - name: GOOGLE_GENAI_USE_VERTEXAI
               value: "1"
             - name: PORT
               value: "8000"
             resources:
               requests:
                 memory: "512Mi"
                 cpu: "500m"
               limits:
                 memory: "1Gi"
                 cpu: "1"
     

     Reemplaza los siguientes valores:

     • IMAGE_URL: Es la URL completa de la imagen de Docker que enviaste a Artifact Registry (por ejemplo, us-central1-docker.pkg.dev/${PROJECT_ID}/adk-repo/adk-agent:latest). Puedes obtener este valor del resultado del comando gcloud artifacts docker images list en la sección anterior. Como alternativa, ejecuta un comando como el siguiente: sed -i "s|image: IMAGE_URL|image: $IMAGE_URL|" agent-deployment.yaml.
     • PROJECT_ID: El ID de tu proyecto de Google Cloud .
     • REGION: Es la Google Cloud región en la que se aprovisiona tu clúster de GKE.

  3. Aplica el manifiesto de la implementación:

     kubectl apply -f agent-deployment.yaml
     

     Este comando crea la Deployment y los Pods asociados para tu aplicación del agente en el clúster de GKE.

  4. Exponer el agente: Puedes usar estos métodos para exponer tu agente y permitir el acceso a él.

     • Para acceder a tu agente desde fuera del clúster, crea un servicio de Kubernetes. Para una API web, es común un servicio de tipo LoadBalancer.

     • Para el desarrollo y las pruebas locales, usa el comando kubectl port-forward para acceder a tu agente directamente.

     LoadBalancer

     1. Crea el siguiente manifiesto como un archivo llamado agent-service.yaml:

        apiVersion: v1
        kind: Service
        metadata:
          name: adk-agent-service
        spec:
          selector:
            app: adk-agent
          type: LoadBalancer # Creates an external IP address for access
          ports:
          -   protocol: TCP
            port: 80
            targetPort: 8000 # Matches the containerPort exposed in the Deployment
        

     2. Aplica el manifiesto

        kubectl apply -f agent-service.yaml
        

        El aprovisionamiento de la dirección IP externa puede tardar unos minutos.

     3. Verifica que se haya aprovisionado la dirección IP:

        kubectl get service adk-agent-service
        

        Busca el valor de EXTERNAL-IP en el resultado. Una vez que el valor esté disponible, usa esta dirección IP para interactuar con el agente implementado.

     port-forward

     Si usas principalmente port-forward, considera usar un tipo de servicio ClusterIP en lugar de LoadBalancer, ya que el servicio ClusterIP es interno y consume menos recursos.

     POD_NAME=$(kubectl get pods -l app=adk-agent -o jsonpath='{.items[0].metadata.name}')
     kubectl port-forward $POD_NAME 8000:8000
     

     Este comando bloquea tu terminal, pero reenvía el tráfico de localhost:8000 en tu máquina al agente que se ejecuta dentro del clúster de GKE.

  Prueba el agente implementado

  Ahora que tu aplicación de agente está implementada y expuesta, prueba su funcionalidad.

  En esta sección, se describe cómo identificar el extremo de tu agente y probar su API.

  1. Identifica el extremo del agente: Según cómo elegiste exponer tu agente en la sección anterior, identifica su extremo accesible:

     LoadBalancer

     1. Recupera la dirección IP externa:

        kubectl get service adk-agent-service -o jsonpath='{.status.loadBalancer.ingress[0].ip}'
        

     2. Almacena la dirección IP externa en una variable de entorno para facilitar su uso:

        export AGENT_IP=$(kubectl get service adk-agent-service -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
        

        La URL base de tu agente es http://${AGENT_IP}.

     port-forward

     Asegúrate de que el comando kubectl port-forward se ejecute en una terminal independiente. La URL base de tu agente es http://localhost:8000.

  2. Prueba la API del agente: Prueba la API del agente realizando una solicitud curl a su extremo /run. El agente espera una carga útil de JSON con un campo de mensaje. Reemplaza AGENT_BASE_URL por http://${AGENT_IP} (para LoadBalancer) o http://localhost:8000 (para reenvío de puertos).

     1. Crea una sesión nueva. Esto prepara al agente para una nueva conversación.

        # The user ID and session ID are arbitrary.
        # The appName must match the agent's Python package directory name (in this case, "capital-agent").
        curl -X POST AGENT_BASE_URL/apps/capital-agent/users/user-123/sessions/session-123
        

        Puedes enumerar las apps disponibles con el siguiente comando:

        curl -X GET AGENT_BASE_URL/list-apps
        

     2. Envía una consulta al agente con los detalles de la sesión del paso anterior.

        curl -X POST AGENT_BASE_URL/run \
        -H "Content-Type: application/json" \
        -d '{
          "appName": "capital-agent",
          "userId": "user-123",
          "sessionId": "session-123",
          "newMessage": {
            "role": "user",
            "parts": [{
              "text": "Hello, agent! What can you do for me?"
            }]
          }
        }'
        

        Deberías recibir una respuesta JSON de tu agente que indique que procesa solicitudes y que interactúa con el modelo de Gemini a través de Vertex AI de forma correcta. La respuesta contiene la contestación generada por el agente en función de tu mensaje.

  3. Accede a la IU web del agente (si corresponde): Si tu agente incluye una interfaz de usuario basada en la Web, accede a ella navegando a tu AGENT_BASE_URL en un navegador web. Por lo general, el ADK incluye una IU web básica para la interacción y la depuración. Por ejemplo, si expusiste tu agente a través de un LoadBalancer y su EXTERNAL-IP es 34.123.45.67, navega a http://34.123.45.67 en tu navegador.

  Limpia

  Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

  Borra los recursos implementados

  Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que creaste en esta guía, ejecuta los siguientes comandos:

  gcloud

  gcloud container clusters delete CLUSTER_NAME \
      --location=${GOOGLE_CLOUD_LOCATION} \
      --project=$PROJECT_ID
  
  gcloud projects remove-iam-policy-binding $PROJECT_ID \
      --member "serviceAccount:vertex-sa@$PROJECT_ID.iam.gserviceaccount.com" \
      --role "roles/aiplatform.user"
  
  gcloud iam service-accounts delete vertex-sa@$PROJECT_ID.iam.gserviceaccount.com
  
  gcloud artifacts repositories delete adk-repo \
      --location=$GOOGLE_CLOUD_LOCATION \
      --project=$PROJECT_ID
  

  Reemplaza CLUSTER_NAME por el nombre de tu clúster de GKE.

  Terraform

  1. En la terminal de Cloud Shell, navega al directorio tutorials-and-examples/adk/vertex/:

     cd tutorials-and-examples/adk/vertex/
     

  2. Ejecuta este comando para quitar todos los recursos definidos en tus archivos de configuración de Terraform.

     cd terraform
     terraform destroy
     

  ¿Qué sigue?

  • Aprende a configurar Horizontal Pod Autoscaler (HPA) para ajustar automáticamente los recursos de tu agente según la demanda.
  • Obtén información para configurar Identity-Aware Proxy (IAP) para tus aplicaciones web que se ejecutan enGoogle Cloud, lo que proporciona autorización centralizada para acceder a la IU de tu agente.
  • Aprende a usar Cloud Logging y Cloud Monitoring para obtener estadísticas sobre el rendimiento y el estado de tu agente en tu clúster de GKE.
  • Explora muestras experimentales en GKE AI Labs que pueden ayudarte a usar GKE para acelerar tus iniciativas de IA basadas en agentes.