Servir modelos abiertos de Gemma con GPUs en GKE con Triton y TensorRT-LLM

En este tutorial se muestra cómo desplegar y servir un modelo de lenguaje grande (LLM) Gemma con GPUs en Google Kubernetes Engine (GKE) mediante la pila de servicio de Triton y TensorRT-LLM de NVIDIA. Esto proporciona una base para comprender y explorar el despliegue práctico de LLMs para la inferencia en un entorno de Kubernetes gestionado. Despliega un contenedor precompilado con Triton y TensorRT-LLM en GKE. También configuras GKE para cargar los pesos de Gemma 2B y 7B.

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

Si necesitas una plataforma de IA gestionada unificada para crear y ofrecer modelos de aprendizaje automático rápidamente y de forma rentable, te recomendamos que pruebes nuestra solución de despliegue Vertex AI.

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 esta guía.

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.

GPUs

Las GPUs te permiten acelerar cargas de trabajo específicas que se ejecutan en tus nodos, como el aprendizaje automático y el procesamiento de datos. GKE ofrece una amplia gama de opciones de tipos de máquinas para la configuración de nodos, incluidos los tipos de máquinas con GPUs NVIDIA H100, L4 y A100.

TensorRT-LLM

NVIDIA TensorRT-LLM (TRT-LLM) es un kit de herramientas con una API de Python para ensamblar soluciones optimizadas que definan LLMs y creen motores TensorRT que realicen inferencias de forma eficiente en GPUs NVIDIA. TensorRT-LLM incluye funciones como las siguientes:

  • Implementación optimizada de Transformer con fusiones de capas, almacenamiento en caché de activaciones, reutilización de búferes de memoria y PagedAttention
  • Agrupación en tiempo real o continua para mejorar el rendimiento general del servicio
  • Paralelismo de tensores y paralelismo de la fase de procesamiento para el servicio distribuido en varias GPUs
  • Cuantización (FP16, FP8, INT8)

Para obtener más información, consulta la documentación de TensorRT-LLM.

Triton

NVIDIA Triton Inference Server es un servidor de inferencia de código abierto para aplicaciones de IA y aprendizaje automático. Triton admite inferencias de alto rendimiento en GPUs y CPUs de NVIDIA con back-ends optimizados, como TensorRT y TensorRT-LLM. Triton incluye funciones como las siguientes:

  • Inferencia con varias GPUs y varios nodos
  • Ejecución simultánea de varios modelos
  • Ensamblaje o encadenamiento de modelos
  • Agrupación estática, dinámica y continua o en tiempo real de solicitudes de predicción

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

Objetivos

  1. Prepara tu entorno con un clúster de GKE en modo Autopilot.
  2. Despliega un contenedor con Triton y TritonRT-LLM en tu clúster.
  3. Usa Triton y TensorRT-LLM para servir el modelo Gemma 2B o 7B a través de curl.

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

    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. Prepara tu 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 CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
export CLUSTER_NAME=CLUSTER_NAME

        Sustituye los siguientes valores:

        • PROJECT_ID: tu Google Cloud ID de proyecto.
        • CONTROL_PLANE_LOCATION: la región de Compute Engine del plano de control de tu clúster. Esta región debe admitir el tipo de acelerador que quieras usar. Por ejemplo, us-central1 para la GPU L4.
        • CLUSTER_NAME: el nombre de tu clúster.

      Acceder al modelo

      Para acceder a los modelos de Gemma, debes iniciar sesión en la plataforma Kaggle y obtener un token de API de Kaggle.

      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 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 dar 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 Crear token.

      Se descarga un archivo llamado kaggle.json.

      Subir el token de acceso a Cloud Shell

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

      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 y configurar Google Cloud recursos

      Sigue estas instrucciones para crear los recursos necesarios.

      Crear un clúster y un grupo de nodos de GKE

      Puedes servir Gemma en GPUs 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 \
  --release-channel=rapid \
  --cluster-version=1.28

      Sustituye los siguientes valores:

      • PROJECT_ID: tu Google Cloud ID de proyecto.
      • CONTROL_PLANE_LOCATION: la región de Compute Engine del plano de control de tu clúster. Esta región debe admitir el tipo de acelerador que quieras usar. Por ejemplo, us-central1 para la GPU L4.
      • CLUSTER_NAME: el nombre de tu clúster.

      GKE crea un clúster de Autopilot con nodos de CPU y GPU según lo soliciten las cargas de trabajo desplegadas.

      Estándar

      1. En Cloud Shell, ejecuta el siguiente comando para crear un clúster Standard:

        gcloud container clusters create CLUSTER_NAME \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --workload-pool=PROJECT_ID.svc.id.goog \
    --release-channel=rapid \
    --machine-type=e2-standard-4 \
    --num-nodes=1

        Sustituye los siguientes valores:

        • PROJECT_ID: tu Google Cloud ID de proyecto.
        • CONTROL_PLANE_LOCATION: la región de Compute Engine del plano de control de tu clúster. Esta región debe admitir el tipo de acelerador que quieras usar. Por ejemplo, us-central1 para la GPU L4.
        • CLUSTER_NAME: el nombre de tu clúster.

        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 gpupool \
    --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --cluster=CLUSTER_NAME \
    --machine-type=g2-standard-12 \
    --num-nodes=1

        GKE crea un único grupo de nodos que contiene un nodo de GPU L4.

      Crear un secreto de Kubernetes para las credenciales de Kaggle

      En este tutorial, se usa 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

        Sustituye los siguientes valores:

        • CONTROL_PLANE_LOCATION: la región de Compute Engine del plano de control de tu clúster. Esta región debe admitir el tipo de acelerador que quieras usar. Por ejemplo, us-central1 para la GPU L4.
        • CLUSTER_NAME: el nombre de tu clúster.

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

        kubectl create secret generic kaggle-secret \
    --from-file=kaggle.json \
    --dry-run=client -o yaml | kubectl apply -f -

      Crear un recurso PersistentVolume para almacenar puntos de control

      En esta sección, crearás un objeto PersistentVolume respaldado por un disco persistente para almacenar los puntos de control del modelo.

      1. Crea el siguiente archivo de manifiesto trtllm_checkpoint_pv.yaml:

        apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: model-data
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 100G

      2. Aplica el archivo de manifiesto:

        kubectl apply -f trtllm_checkpoint_pv.yaml

      Descargar los archivos del motor TensorRT-LLM para Gemma

      En esta sección, ejecutarás un trabajo de Kubernetes para completar las siguientes tareas:

      • Descarga los archivos del motor TensorRT-LLM y guárdalos en el PersistentVolume que has creado anteriormente.
      • Prepara los archivos de configuración para desplegar el modelo en el servidor Triton.

      Un controlador de trabajo de Kubernetes crea uno o varios pods y se asegura de que ejecuten correctamente una tarea específica.

      El siguiente proceso puede tardar unos minutos.

      Gemma 2B-it

      El motor TensorRT-LLM se ha creado a partir del punto de control de PyTorch de Gemma 2B-it (ajustado para instrucciones) de Gemma con la activación bfloat16, una longitud de secuencia de entrada de 2048 y una longitud de secuencia de salida de 1024 para las GPUs L4. Puedes desplegar el modelo en una sola GPU L4.

      1. Crea el siguiente archivo de manifiesto job-download-gemma-2b.yaml:

        apiVersion: v1
kind: ConfigMap
metadata:
  name: fetch-model-scripts
data:
  fetch_model.sh: |-
    #!/usr/bin/bash -x
    pip install kaggle --break-system-packages && \

    MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
    VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
    ACTIVATION_DTYPE=bfloat16 && \

    TOKENIZER_DIR=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/tokenizer.model && \
    ENGINE_PATH=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/ && \
    TRITON_MODEL_REPO=/data/triton/model_repository && \

    mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    mkdir -p ${ENGINE_PATH} && \
    mkdir -p ${TRITON_MODEL_REPO} && \

    kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    rm -f /data/${MODEL_NAME}_${VARIATION_NAME}/*.tar.gz && \
    find /data/${MODEL_NAME}_${VARIATION_NAME} -type f && \
    find /data/${MODEL_NAME}_${VARIATION_NAME} -type f | xargs -I '{}' mv '{}' ${ENGINE_PATH} && \

    # copying configuration files
    echo -e "\nCreating configuration files" && \
    cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* ${TRITON_MODEL_REPO} && \

    # updating configuration files
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,preprocessing_instance_count:1 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,postprocessing_instance_count:1 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,bls_instance_count:1,accumulate_tokens:False && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/ensemble/config.pbtxt triton_max_batch_size:64 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,max_beam_width:1,engine_dir:${ENGINE_PATH},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:inflight_batching,max_queue_delay_microseconds:600,batch_scheduler_policy:guaranteed_no_evict,enable_trt_overlap:False && \

    echo -e "\nCompleted extraction to ${ENGINE_PATH}"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-gemma-2b
  labels:
    app: data-loader-gemma-2b
spec:
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        app: data-loader-gemma-2b
    spec:
      restartPolicy: OnFailure
      containers:
      - name: gcloud
        image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
        command:
        - /scripts/fetch_model.sh
        env:
        - name: KAGGLE_CONFIG_DIR
          value: /kaggle
        - name: MODEL_PATH
          value: "google/gemma/tensorrtllm/2b-it/2"
        - name: WORLD_SIZE
          value: "1"
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
        - mountPath: "/data"
          name: data
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: fetch-model-scripts
      - name: data
        persistentVolumeClaim:
          claimName: model-data
      tolerations:
      - key: "key"
        operator: "Exists"
        effect: "NoSchedule"

      2. Aplica el archivo de manifiesto:

        kubectl apply -f job-download-gemma-2b.yaml

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

        kubectl logs -f job/data-loader-gemma-2b

        La salida de los registros es similar a la siguiente:

        ...
Creating configuration files
+ echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/2b/bfloat16/1-gpu/'
+ echo -e '\nCreating configuration files'
...

      4. Espera a que se complete el trabajo:

        kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-2b

        El resultado debería ser similar al siguiente:

        job.batch/data-loader-gemma-2b condition met

      5. Verifica que el trabajo se haya completado correctamente (puede tardar unos minutos):

        kubectl get job/data-loader-gemma-2b

        El resultado debería ser similar al siguiente:

        NAME             COMPLETIONS   DURATION   AGE
data-loader-gemma-2b   1/1           ##s        #m##s

      Gemma 7B-it

      El motor TensorRT-LLM se ha creado a partir del punto de control de PyTorch de Gemma 7B-it (ajustado para instrucciones) de Gemma con la activación bfloat16, una longitud de secuencia de entrada de 1024 y una longitud de secuencia de salida de 512 para las GPUs L4. Puedes desplegar el modelo en una sola GPU L4.

      1. Crea el siguiente archivo de manifiesto job-download-gemma-7b.yaml:

        apiVersion: v1
kind: ConfigMap
metadata:
  name: fetch-model-scripts
data:
  fetch_model.sh: |-
    #!/usr/bin/bash -x
    pip install kaggle --break-system-packages && \

    MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
    VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
    ACTIVATION_DTYPE=bfloat16 && \

    TOKENIZER_DIR=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/tokenizer.model && \
    ENGINE_PATH=/data/trt_engine/${MODEL_NAME}/${VARIATION_NAME}/${ACTIVATION_DTYPE}/${WORLD_SIZE}-gpu/ && \
    TRITON_MODEL_REPO=/data/triton/model_repository && \

    mkdir -p ${ENGINE_PATH} && \
    mkdir -p ${TRITON_MODEL_REPO} && \

    kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
    rm -f /data/${MODEL_NAME}_${VARIATION_NAME}/*.tar.gz && \
    find /data/${MODEL_NAME}_${VARIATION_NAME} -type f && \
    find /data/${MODEL_NAME}_${VARIATION_NAME} -type f | xargs -I '{}' mv '{}' ${ENGINE_PATH} && \

    # copying configuration files
    echo -e "\nCreating configuration files" && \
    cp -r /tensorrtllm_backend/all_models/inflight_batcher_llm/* ${TRITON_MODEL_REPO} && \

    # updating configuration files
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/preprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,preprocessing_instance_count:1 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/postprocessing/config.pbtxt tokenizer_dir:${TOKENIZER_DIR},tokenizer_type:sp,triton_max_batch_size:64,postprocessing_instance_count:1 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm_bls/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,bls_instance_count:1,accumulate_tokens:False && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/ensemble/config.pbtxt triton_max_batch_size:64 && \
    python3 /tensorrtllm_backend/tools/fill_template.py -i ${TRITON_MODEL_REPO}/tensorrt_llm/config.pbtxt triton_max_batch_size:64,decoupled_mode:False,max_beam_width:1,engine_dir:${ENGINE_PATH},max_tokens_in_paged_kv_cache:2560,max_attention_window_size:2560,kv_cache_free_gpu_mem_fraction:0.5,exclude_input_in_output:True,enable_kv_cache_reuse:False,batching_strategy:inflight_batching,max_queue_delay_microseconds:600,batch_scheduler_policy:guaranteed_no_evict,enable_trt_overlap:False && \

    echo -e "\nCompleted extraction to ${ENGINE_PATH}"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: data-loader-gemma-7b
  labels:
    app: data-loader-gemma-7b
spec:
  ttlSecondsAfterFinished: 120
  template:
    metadata:
      labels:
        app: data-loader-gemma-7b
    spec:
      restartPolicy: OnFailure
      containers:
      - name: gcloud
        image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
        command:
        - /scripts/fetch_model.sh
        env:
        - name: KAGGLE_CONFIG_DIR
          value: /kaggle
        - name: MODEL_PATH
          value: "google/gemma/tensorrtllm/7b-it/2"
        - name: WORLD_SIZE
          value: "1"
        volumeMounts:
        - mountPath: "/kaggle/"
          name: kaggle-credentials
          readOnly: true
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
        - mountPath: "/data"
          name: data
      volumes:
      - name: kaggle-credentials
        secret:
          defaultMode: 0400
          secretName: kaggle-secret
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: fetch-model-scripts
      - name: data
        persistentVolumeClaim:
          claimName: model-data
      tolerations:
      - key: "key"
        operator: "Exists"
        effect: "NoSchedule"

      2. Aplica el archivo de manifiesto:

        kubectl apply -f job-download-gemma-7b.yaml

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

        kubectl logs -f job/data-loader-gemma-7b

        La salida de los registros es similar a la siguiente:

        ...
Creating configuration files
+ echo -e '\n02-16-2024 04:07:45 Completed building TensortRT-LLM engine at /data/trt_engine/gemma/7b/bfloat16/1-gpu/'
+ echo -e '\nCreating configuration files'
...

      4. Espera a que se complete el trabajo:

        kubectl wait --for=condition=complete --timeout=900s job/data-loader-gemma-7b

        El resultado debería ser similar al siguiente:

        job.batch/data-loader-gemma-7b condition met

      5. Verifica que el trabajo se haya completado correctamente (puede tardar unos minutos):

        kubectl get job/data-loader-gemma-7b

        El resultado debería ser similar al siguiente:

        NAME             COMPLETIONS   DURATION   AGE
data-loader-gemma-7b   1/1           ##s        #m##s

      Asegúrate de que el trabajo se haya completado correctamente antes de pasar a la siguiente sección.

      Desplegar Triton

      En esta sección, desplegarás un contenedor que usa Triton con el backend TensorRT-LLM para servir el modelo de Gemma que quieras usar.

      1. Crea el siguiente archivo de manifiesto deploy-triton-server.yaml:

        apiVersion: v1
kind: ConfigMap
metadata:
  name: launch-tritonserver
data:
  entrypoint.sh: |-
    #!/usr/bin/bash -x
    # Launch Triton Inference server

    WORLD_SIZE=1
    TRITON_MODEL_REPO=/data/triton/model_repository

    python3 /tensorrtllm_backend/scripts/launch_triton_server.py \
      --world_size ${WORLD_SIZE} \
      --model_repo ${TRITON_MODEL_REPO}

    tail -f /dev/null
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: triton-gemma-deployment
  labels:
    app: gemma-server
    version: v1 
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server 
      version: v1
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma
        ai.gke.io/inference-server: triton
        examples.ai.gke.io/source: user-guide
        version: v1
    spec:
      containers:
      - name: inference-server 
        image: us-docker.pkg.dev/google-samples/containers/gke/tritonserver:2.42.0
        imagePullPolicy: IfNotPresent
        resources:
          requests:
            ephemeral-storage: "40Gi"
            memory: "40Gi"
            nvidia.com/gpu: 1
          limits:
            ephemeral-storage: "40Gi"
            memory: "40Gi"
            nvidia.com/gpu: 1
        command:
        - /scripts/entrypoint.sh
        volumeMounts:
        - mountPath: "/scripts/"
          name: scripts-volume
          readOnly: true
        - mountPath: "/data"
          name: data
        ports:
          - containerPort: 8000
            name: http
          - containerPort: 8001
            name: grpc
          - containerPort: 8002
            name: metrics
        livenessProbe:
          failureThreshold: 60
          initialDelaySeconds: 600
          periodSeconds: 5
          httpGet:
            path: /v2/health/live
            port: http
        readinessProbe:
          failureThreshold: 60
          initialDelaySeconds: 600
          periodSeconds: 5
          httpGet:
            path: /v2/health/ready
            port: http
      securityContext:
        runAsUser: 1000
        fsGroup: 1000
      volumes:
      - name: scripts-volume
        configMap:
          defaultMode: 0700
          name: launch-tritonserver
      - name: data
        persistentVolumeClaim:
          claimName: model-data
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
      tolerations:
      - key: "key"
        operator: "Exists"
        effect: "NoSchedule"
---
apiVersion: v1
kind: Service
metadata:
  name: triton-server
  labels:
    app: gemma-server 
spec:
  type: ClusterIP
  ports:
    - port: 8000
      targetPort: http
      name: http-inference-server
    - port: 8001
      targetPort: grpc
      name: grpc-inference-server
    - port: 8002
      targetPort: metrics
      name: http-metrics
  selector:
    app: gemma-server

      2. Aplica el archivo de manifiesto:

        kubectl apply -f deploy-triton-server.yaml

      3. Espera a que esté disponible el despliegue:

        kubectl wait --for=condition=Available --timeout=900s deployment/triton-gemma-deployment

      4. Consulta los registros del manifiesto:

        kubectl logs -f -l app=gemma-server

        El recurso de implementación inicia el servidor Triton y carga los datos del modelo. Este proceso puede tardar unos minutos (hasta 20 minutos o más). La salida es similar a la siguiente:

        I0216 03:24:57.387420 29 server.cc:676]
+------------------+---------+--------+
| Model            | Version | Status |
+------------------+---------+--------+
| ensemble         | 1       | READY  |
| postprocessing   | 1       | READY  |
| preprocessing    | 1       | READY  |
| tensorrt_llm     | 1       | READY  |
| tensorrt_llm_bls | 1       | READY  |
+------------------+---------+--------+

....
....
....

I0216 03:24:57.425104 29 grpc_server.cc:2519] Started GRPCInferenceService at 0.0.0.0:8001
I0216 03:24:57.425418 29 http_server.cc:4623] Started HTTPService at 0.0.0.0:8000
I0216 03:24:57.466646 29 http_server.cc:315] Started Metrics Service at 0.0.0.0:8002

      Aplicar el modelo

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

      Configurar la redirección de puertos

      Ejecuta el siguiente comando para configurar el reenvío de puertos al modelo:

      kubectl port-forward service/triton-server 8000:8000

      El resultado debería ser similar al siguiente:

      Forwarding from 127.0.0.1:8000 -> 8000
Forwarding from [::1]:8000 -> 8000
Handling connection for 8000

      Interactuar con el modelo mediante curl

      En esta sección se muestra cómo realizar una prueba de humo básica para verificar el modelo ajustado con instrucciones que has implementado. Para simplificar, en esta sección se describe el método de prueba solo con el modelo ajustado de 2B instrucciones.

      En una nueva sesión de terminal, usa curl para chatear con tu modelo:

      USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"

curl -X POST localhost:8000/v2/models/ensemble/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "text_input": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "temperature": 0.9,
    "max_tokens": 128
}
EOF

      En el siguiente resultado se muestra un ejemplo de la respuesta del modelo:

      {
  "context_logits": 0,
  "cum_log_probs": 0,
  "generation_logits": 0,
  "model_name": "ensemble",
  "model_version": "1",
  "output_log_probs": [0.0,0.0,...],
  "sequence_end": false,
  "sequence_id": 0,
  "sequence_start": false,
  "text_output":"Python.\n\nPython is an excellent choice for beginners due to its simplicity, readability, and extensive documentation. Its syntax is close to natural language, making it easier for beginners to understand and write code. Python also has a vast collection of libraries and tools that make it versatile for various projects. Additionally, Python's dynamic nature allows for easier learning and experimentation, making it a perfect choice for newcomers to get started.Here are some specific reasons why Python is a good choice for beginners:\n\n- Simple and Easy to Read: Python's syntax is designed to be close to natural language, making it easier for"
}

      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 el siguiente comando:

      gcloud container clusters delete CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

      Siguientes pasos