Sirve Gemma mediante TPUs en GKE con JetStream

En este tutorial se muestra cómo servir un modelo de lenguaje grande (LLM) Gemma mediante unidades de procesamiento de tensor (TPUs) en Google Kubernetes Engine (GKE). Despliega un contenedor prediseñado con JetStream y MaxText en GKE. También debes configurar GKE para que cargue los pesos de Gemma 7B desde Cloud Storage en el tiempo de ejecución.

Este tutorial está dirigido a ingenieros de aprendizaje automático, administradores y operadores de plataformas, y especialistas en datos e IA que quieran usar las funciones de orquestación de contenedores de Kubernetes para ofrecer LLMs. Para obtener más información sobre los roles habituales y las tareas de ejemplo a las que hacemos referencia en el contenido, consulta Roles y tareas de usuario habituales de GKE.Google Cloud

Antes de leer esta página, asegúrese de que conoce los siguientes conceptos:

Fondo

En esta sección se describen las tecnologías clave que se usan en este tutorial.

Gemma

Gemma es un conjunto de modelos de inteligencia artificial (IA) generativa ligeros y disponibles públicamente que se han lanzado con una licencia abierta. Estos modelos de IA se pueden ejecutar en tus aplicaciones, hardware, dispositivos móviles o servicios alojados. Puedes usar los modelos Gemma para generar texto, pero también puedes ajustarlos para tareas especializadas.

Para obtener más información, consulta la documentación de Gemma.

TPUs

Las TPUs son circuitos integrados para aplicaciones específicas (ASIC) desarrollados a medida por Google que se utilizan para acelerar los modelos de aprendizaje automático y de IA creados con frameworks como TensorFlow, PyTorch y JAX.

En este tutorial se explica cómo servir el modelo Gemma 7B. GKE implementa el modelo en nodos TPU v5e de un solo host con topologías de TPU configuradas en función de los requisitos del modelo para servir peticiones con baja latencia.

JetStream

JetStream es un framework de servicio de inferencia de código abierto desarrollado por Google. JetStream permite realizar inferencias de alto rendimiento, alto volumen de procesamiento y memoria optimizada en TPUs y GPUs. Ofrece optimizaciones de rendimiento avanzadas, como técnicas de cuantización y procesamiento por lotes continuo, para facilitar la implementación de LLMs. JetStream permite que el servicio de TPU de PyTorch/XLA y JAX consiga un rendimiento óptimo.

Para obtener más información sobre estas optimizaciones, consulta los repositorios de proyectos JetStream PyTorch y JetStream MaxText.

MaxText

MaxText es una implementación de LLM de JAX de alto rendimiento, escalable y adaptable, creada a partir de bibliotecas de JAX de código abierto, como Flax, Orbax y Optax. La implementación de LLM solo con decodificador de MaxText está escrita en Python. Aprovecha el compilador XLA para conseguir un alto rendimiento sin necesidad de crear kernels personalizados.

Para obtener más información sobre los modelos y tamaños de parámetros más recientes que admite MaxText, consulta el repositorio del proyecto MaxText.

Objetivos

  1. Prepara un clúster de Autopilot o Estándar de GKE con la topología de TPU recomendada en función de las características del modelo.
  2. Despliega componentes de JetStream en GKE.
  3. Obtén y publica el modelo ajustado de instrucciones de Gemma 7B.
  4. Ofrece e interactúa con el modelo publicado.

Arquitectura

En esta sección se describe la arquitectura de GKE que se usa en este tutorial. La arquitectura consta de un clúster de Autopilot o Standard de GKE que aprovisiona TPUs y aloja componentes de JetStream para implementar y servir los modelos.

En el siguiente diagrama se muestran los componentes de esta arquitectura:

Arquitectura de un clúster de GKE con grupos de nodos de TPU de un solo host que contienen los componentes Maxengine y Max HTTP.

Esta arquitectura incluye los siguientes componentes:

  • Un clúster regional de Autopilot o Estándar de GKE.
  • Dos grupos de nodos de segmentos de TPU de un solo host que alojan la implementación de JetStream.
  • El componente Service distribuye el tráfico entrante a todas las réplicas de JetStream HTTP.
  • JetStream HTTP es un servidor HTTP que acepta solicitudes como envoltorio del formato requerido de JetStream y las envía al cliente GRPC de JetStream.
  • Maxengine es un servidor JetStream que realiza inferencias con el procesamiento por lotes continuo.

Antes de empezar

  • 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.

    Go to project selector

  • Verify that billing is enabled for your Google Cloud project.

  • Enable the required API.

    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 API

  • 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.

    Go to project selector

  • Verify that billing is enabled for your Google Cloud project.

  • Enable the required API.

    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 API

    •

  • Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin, 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 Conceder acceso.

    4. En el campo Nuevos principales, introduce tu identificador de usuario. Normalmente, se trata de la dirección de correo de una cuenta de Google.

    5. En la lista Selecciona un rol, elige un rol.
    6. Para conceder más roles, haz clic en Añadir otro rol y añade cada rol adicional.
    7. Haz clic en Guardar.

      8. Acceder al modelo

      Para acceder al modelo Gemma e implementarlo en GKE, primero debes firmar el contrato de consentimiento de licencia.

      Debes firmar el acuerdo de consentimiento para usar Gemma. Te las indicamos a continuación:

      1. Accede a la página de consentimiento del modelo Gemma en Kaggle.com.
      2. Inicia sesión en Kaggle si aún no lo has hecho.
      3. Haz clic en Solicitar acceso.
      4. En la sección Choose Account for Consent (Elegir cuenta para el consentimiento), selecciona Verify via Kaggle Account (Verificar con la cuenta de Kaggle) para usar tu cuenta de Kaggle para el consentimiento.
      5. Acepta los Términos y Condiciones del modelo.

      Generar un token de acceso

      Para acceder al modelo a través de Kaggle, necesitas un token de la API de Kaggle.

      Sigue estos pasos para generar un token si aún no tienes uno:

      1. En tu navegador, ve a Configuración de Kaggle.
      2. En la sección API, haz clic en Create New Token (Crear token).

      Se descarga un archivo llamado kaggle.json.

      Preparar el entorno

      En este tutorial, usarás Cloud Shell para gestionar los recursos alojados enGoogle Cloud. Cloud Shell tiene preinstalado el software que necesitarás para este tutorial, como kubectl y la CLI de gcloud.

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

      1. En la Google Cloud consola, inicia una sesión de Cloud Shell haciendo clic en Icono de activación de Cloud Shell Activar Cloud Shell en la Google Cloud consola. Se iniciará una sesión en el panel inferior de la consola Google Cloud .

      2. Define las variables de entorno predeterminadas:

        gcloud config set project PROJECT_ID
gcloud config set billing/quota_project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export CLUSTER_NAME=CLUSTER_NAME
export BUCKET_NAME=BUCKET_NAME
export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
export NODE_LOCATION=NODE_LOCATION
export CLUSTER_VERSION=CLUSTER_VERSION

        Sustituye los siguientes valores:

        • PROJECT_ID: tu Google Cloud ID de proyecto.
        • CLUSTER_NAME: el nombre de tu clúster de GKE.
        • BUCKET_NAME: el nombre de tu segmento de Cloud Storage. No es necesario que especifiques el prefijo gs://.
        • CONTROL_PLANE_LOCATION: la región de Compute Engine del plano de control de tu clúster. Esta región debe contener zonas en las que estén disponibles los tipos de máquina TPU v5e (por ejemplo, us-west1, us-west4, us-central1, us-east1, us-east5 o europe-west4). En el caso de los clústeres Autopilot, asegúrate de que tienes suficientes recursos zonales de TPU v5e en la región que elijas.
        • (Solo en clústeres estándar) NODE_LOCATION: la zona en la que están disponibles los recursos de TPU (por ejemplo, us-west4-a). En los clústeres de Autopilot, no es necesario especificar este valor.
        • CLUSTER_VERSION: la versión de GKE, que debe admitir el tipo de máquina que quieras usar. Ten en cuenta que es posible que la versión predeterminada de GKE no esté disponible para tu TPU de destino. Para ver una lista de las versiones mínimas de GKE disponibles por tipo de máquina de TPU, consulta Disponibilidad de TPU en GKE.

      Crear y configurar Google Cloud recursos

      Sigue estas instrucciones para crear los recursos necesarios.

      Crear un clúster de GKE

      Puedes servir Gemma en TPUs en un clúster Autopilot o Standard de GKE. Te recomendamos que uses un clúster de Autopilot para disfrutar de una experiencia de Kubernetes totalmente gestionada. Para elegir el modo de funcionamiento de GKE que mejor se adapte a tus cargas de trabajo, consulta Elegir un modo de funcionamiento de GKE.

      Autopilot

      En Cloud Shell, ejecuta el siguiente comando:

      gcloud container clusters create-auto ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --location=${CONTROL_PLANE_LOCATION} \
  --cluster-version=${CLUSTER_VERSION}

      Estándar

      1. Crea un clúster estándar de GKE regional que use Workload Identity Federation para GKE.

        gcloud container clusters create ${CLUSTER_NAME} \
    --enable-ip-alias \
    --machine-type=e2-standard-4 \
    --num-nodes=2 \
    --cluster-version=${CLUSTER_VERSION} \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --location=${CONTROL_PLANE_LOCATION}

        La creación del clúster puede tardar varios minutos.

      2. Ejecuta el siguiente comando para crear un grupo de nodos para tu clúster:

        gcloud container node-pools create gemma-7b-tpu-nodepool \
  --cluster=${CLUSTER_NAME} \
  --machine-type=ct5lp-hightpu-8t \
  --project=${PROJECT_ID} \
  --num-nodes=2 \
  --location=${CONTROL_PLANE_LOCATION} \
  --node-locations=${NODE_LOCATION}

        GKE crea un grupo de nodos de TPU v5e con una topología 2x4 y dos nodos.

      Crea un segmento de Cloud Storage

      En Cloud Shell, ejecuta el siguiente comando:

      gcloud storage buckets create gs://${BUCKET_NAME} --location=${CONTROL_PLANE_LOCATION}

      De esta forma, se crea un segmento de Cloud Storage para almacenar los archivos del modelo que descargues de Kaggle.

      Subir el token de acceso a Cloud Shell

      En Cloud Shell, puedes subir el token de la API de Kaggle a tu proyecto: Google Cloud

      1. En Cloud Shell, haz clic en Más > Subir.
      2. Selecciona Archivo y haz clic en Elegir archivos.
      3. Abre el archivo kaggle.json.
      4. Haz clic en Subir.

      Crear un secreto de Kubernetes para las credenciales de Kaggle

      En Cloud Shell, haz lo siguiente:

      1. Configura kubectl para que se comunique con tu clúster:

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

      2. Crea un secreto para almacenar las credenciales de Kaggle:

        kubectl create secret generic kaggle-secret \
    --from-file=kaggle.json

      Configurar el acceso de las cargas de trabajo mediante Workload Identity Federation para GKE

      Asigna una cuenta de servicio de Kubernetes a la aplicación y configura esa cuenta de servicio de Kubernetes para que actúe como cuenta de servicio de gestión de identidades y accesos.

      1. Crea una cuenta de servicio de IAM para tu aplicación:

        gcloud iam service-accounts create wi-jetstream

      2. Añade una vinculación de política de gestión de identidades y accesos a tu cuenta de servicio de gestión de identidades y accesos para gestionar Cloud Storage:

        gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role roles/storage.objectUser

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role roles/storage.insightsCollectorService

      3. Permite que la cuenta de servicio de Kubernetes suplante la identidad de la cuenta de servicio de gestión de identidades y accesos añadiendo un enlace de política de gestión de identidades y accesos entre las dos cuentas de servicio. Este enlace permite que la cuenta de servicio de Kubernetes actúe como cuenta de servicio de gestión de identidades y accesos:

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

      4. Anota la cuenta de servicio de Kubernetes con la dirección de correo de la cuenta de servicio de gestión de identidades y accesos:

        kubectl annotate serviceaccount default \
    iam.gke.io/gcp-service-account=wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com

      Convertir los puntos de control del modelo

      En esta sección, crearás un trabajo para hacer lo siguiente:

      1. Descarga el punto de control base de Orbax de Kaggle.
      2. Sube el punto de control a un segmento de Cloud Storage.
      3. Convierte el punto de control en un punto de control compatible con MaxText.
      4. Desactiva el checkpoint que se va a usar para el servicio.

      Desplegar el trabajo de conversión de punto de control del modelo

      Sigue estas instrucciones para descargar y convertir los archivos de punto de control del modelo Gemma 7B. En este tutorial se usa un trabajo de Kubernetes. Un controlador de trabajo de Kubernetes crea uno o varios pods y se asegura de que ejecuten correctamente una tarea específica.

      1. Crea el siguiente archivo de manifiesto como job-7b.yaml.

        apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-7b
spec:
  ttlSecondsAfterFinished: 30
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: inference-checkpoint
        image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.4
        args:
        - -b=BUCKET_NAME
        - -m=google/gemma/maxtext/7b-it/2
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret

      2. Aplica el archivo de manifiesto:

        kubectl apply -f job-7b.yaml

      3. Espera a que el pod que programa el trabajo empiece a ejecutarse:

        kubectl get pod -w

        El resultado será similar al siguiente y puede tardar unos minutos:

        NAME                  READY   STATUS              RESTARTS   AGE
data-loader-7b-abcd   0/1     ContainerCreating   0          28s
data-loader-7b-abcd   1/1     Running             0          51s

        En el caso de los clústeres Autopilot, puede que se tarden unos minutos en aprovisionar los recursos de TPU necesarios.

      4. Para ver los registros de la tarea, haz lo siguiente:

        kubectl logs -f jobs/data-loader-7b

        Cuando se complete la tarea, la salida será similar a la siguiente:

        Successfully generated decode checkpoint at: gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
+ echo -e '\nCompleted unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items'

Completed unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items

      Desplegar JetStream

      En esta sección, desplegarás el contenedor de JetStream para servir el modelo de Gemma.

      Sigue estas instrucciones para implementar el modelo Gemma 7B ajustado para instrucciones. En este tutorial se usa un Deployment de Kubernetes. Un Deployment es un objeto de la API de Kubernetes que te permite ejecutar varias réplicas de pods distribuidas entre los nodos de un clúster.

      1. Guarda el siguiente archivo de manifiesto de implementación como jetstream-gemma-deployment.yaml:

        apiVersion: apps/v1
kind: Deployment
metadata:
  name: maxengine-server
spec:
  replicas: 1
  selector:
    matchLabels:
      app: maxengine-server
  template:
    metadata:
      labels:
        app: maxengine-server
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      containers:
      - name: maxengine-server
        image: us-docker.pkg.dev/cloud-tpu-images/inference/maxengine-server:v0.2.2
        args:
        - model_name=gemma-7b
        - tokenizer_path=assets/tokenizer.gemma
        - per_device_batch_size=4
        - max_prefill_predict_length=1024
        - max_target_length=2048
        - async_checkpointing=false
        - ici_fsdp_parallelism=1
        - ici_autoregressive_parallelism=-1
        - ici_tensor_parallelism=1
        - scan_layers=false
        - weight_dtype=bfloat16
        - load_parameters_path=gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
        - prometheus_port=PROMETHEUS_PORT
        ports:
        - containerPort: 9000
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      - name: jetstream-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.2
        ports:
        - containerPort: 8000
---
apiVersion: v1
kind: Service
metadata:
  name: jetstream-svc
spec:
  selector:
    app: maxengine-server
  ports:
  - protocol: TCP
    name: jetstream-http
    port: 8000
    targetPort: 8000
  - protocol: TCP
    name: jetstream-grpc
    port: 9000
    targetPort: 9000

        El manifiesto define las siguientes propiedades clave:

        • tokenizer_path: la ruta al tokenizador de tu modelo.
        • load_parameters_path: la ruta del segmento de Cloud Storage donde se almacenan los puntos de control.
        • per_device_batch_size: el tamaño del lote de decodificación por dispositivo, donde un chip de TPU equivale a un dispositivo.
        • max_prefill_predict_length: la longitud máxima del texto predefinido al hacer una autorregresión.
        • max_target_length: longitud máxima de la secuencia.
        • model_name: el nombre del modelo (gemma-7b).
        • ici_fsdp_parallelism: número de particiones para el paralelismo de datos totalmente particionados (FSDP).
        • ici_tensor_parallelism: el número de fragmentos para el paralelismo de tensores.
        • ici_autoregressive_parallelism: el número de fragmentos para el paralelismo autorregresivo.
        • prometheus_port: puerto para exponer métricas de Prometheus. Elimina este argumento si no necesitas las métricas.
        • scan_layers: marca booleana de capas de análisis (booleano).
        • weight_dtype: el tipo de datos de peso (bfloat16).

      2. Aplica el archivo de manifiesto:

        kubectl apply -f jetstream-gemma-deployment.yaml

      3. Verifica la implementación:

        kubectl get deployment

        El resultado debería ser similar al siguiente:

        NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
maxengine-server                  2/2     2            2           ##s

        En el caso de los clústeres Autopilot, puede que se tarden unos minutos en aprovisionar los recursos de TPU necesarios.

      4. Consulta los registros del servidor HTTP para comprobar que el modelo se ha cargado y compilado. El servidor puede tardar unos minutos en completar esta operación.

        kubectl logs deploy/maxengine-server -f -c jetstream-http

        El resultado debería ser similar al siguiente:

        kubectl logs deploy/maxengine-server -f -c jetstream-http

INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

      5. Consulta los registros de MaxEngine y comprueba que la compilación se ha completado.

        kubectl logs deploy/maxengine-server -f -c maxengine-server

        El resultado debería ser similar al siguiente:

        2024-03-29 17:09:08,047 - jax._src.dispatch - DEBUG - Finished XLA compilation of jit(initialize) in 0.26236414909362793 sec
2024-03-29 17:09:08,150 - root - INFO - ---------Generate params 0 loaded.---------

      Aplicar el modelo

      En esta sección, interactúas con el modelo.

      Configurar la redirección de puertos

      Puedes acceder a la implementación de JetStream a través del servicio ClusterIP que has creado en el paso anterior. Solo se puede acceder a los servicios ClusterIP desde el clúster. Por lo tanto, para acceder al servicio desde fuera del clúster, sigue estos pasos:

      Para establecer una sesión de reenvío de puertos, ejecuta el siguiente comando:

      kubectl port-forward svc/jetstream-svc 8000:8000

      Interactuar con el modelo mediante curl

      1. Verifica que puedes acceder al servidor HTTP de JetStream abriendo un nuevo terminal y ejecutando el siguiente comando:

        curl --request POST \
--header "Content-type: application/json" \
-s \
localhost:8000/generate \
--data \
'{
    "prompt": "What are the top 5 programming languages",
    "max_tokens": 200
}'

        La solicitud inicial puede tardar varios segundos en completarse debido al calentamiento del modelo. El resultado debería ser similar al siguiente:

        {
    "response": "\nfor data science in 2023?\n\n**1. Python:**\n- Widely used for data science due to its simplicity, readability, and extensive libraries for data wrangling, analysis, visualization, and machine learning.\n- Popular libraries include pandas, scikit-learn, and matplotlib.\n\n**2. R:**\n- Statistical programming language widely used for data analysis, visualization, and modeling.\n- Popular libraries include ggplot2, dplyr, and caret.\n\n**3. Java:**\n- Enterprise-grade language with strong performance and scalability.\n- Popular libraries include Spark, TensorFlow, and Weka.\n\n**4. C++:**\n- High-performance language often used for data analytics and machine learning models.\n- Popular libraries include TensorFlow, PyTorch, and OpenCV.\n\n**5. SQL:**\n- Relational database language essential for data wrangling and querying large datasets.\n- Popular tools"
}

      (Opcional) Interactúa con el modelo a través de una interfaz de chat de Gradio

      En esta sección, crearás una aplicación de chat web que te permitirá interactuar con tu modelo ajustado con instrucciones.

      Gradio es una biblioteca de Python que tiene un ChatInterface wrapper que crea interfaces de usuario para chatbots.

      Implementar la interfaz de chat

      1. En Cloud Shell, guarda el siguiente manifiesto como gradio.yaml:

        apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradio
  labels:
    app: gradio
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gradio
  template:
    metadata:
      labels:
        app: gradio
    spec:
      containers:
      - name: gradio
        image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.3
        resources:
          requests:
            cpu: "512m"
            memory: "512Mi"
          limits:
            cpu: "1"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/generate"
        - name: HOST
          value: "http://jetstream-svc:8000"
        - name: LLM_ENGINE
          value: "max"
        - name: MODEL_ID
          value: "gemma"
        - name: USER_PROMPT
          value: "<start_of_turn>user\nprompt<end_of_turn>\n"
        - name: SYSTEM_PROMPT
          value: "<start_of_turn>model\nprompt<end_of_turn>\n"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio
spec:
  selector:
    app: gradio
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 7860
  type: ClusterIP

      2. Aplica el archivo de manifiesto:

        kubectl apply -f gradio.yaml

      3. Espera a que esté disponible el despliegue:

        kubectl wait --for=condition=Available --timeout=300s deployment/gradio

      Usar la interfaz de chat

      1. En Cloud Shell, ejecuta el siguiente comando:

        kubectl port-forward service/gradio 8080:8080

        De esta forma, se crea un reenvío de puertos de Cloud Shell al servicio de Gradio.

      2. Haz clic en el botón Icono de vista previa web Vista previa web, situado en la parte superior derecha de la barra de tareas de Cloud Shell. Haz clic en Vista previa en el puerto 8080. Se abrirá una nueva pestaña en el navegador.

      3. Interactúa con Gemma mediante la interfaz de chat de Gradio. Añade una petición y haz clic en Enviar.

      Solucionar problemas

      Limpieza

      Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud, elimina el proyecto que contiene los recursos o conserva el proyecto y elimina los recursos.

      Eliminar los recursos desplegados

      Para evitar que se apliquen cargos en tu cuenta de Google Cloud por los recursos que has creado en esta guía, ejecuta los siguientes comandos y sigue las indicaciones:

      gcloud container clusters delete ${CLUSTER_NAME} --location=${CONTROL_PLANE_LOCATION}

gcloud iam service-accounts delete wi-jetstream@PROJECT_ID.iam.gserviceaccount.com

gcloud storage rm --recursive gs://BUCKET_NAME

      Siguientes pasos