Se usó la API de Cloud Translation para traducir esta página.

Implementa un modelo de IA en GKE con NVIDIA NIM

1. Introducción

En este Codelab práctico, se te guiará para implementar y administrar un modelo de IA en contenedores en Google Kubernetes Engine (GKE) con la potencia de los microservicios de NVIDIA NIM™.

Este instructivo está diseñado para desarrolladores y científicos de datos que buscan hacer lo siguiente:

Simplifica la implementación de la inferencia de IA: Aprende a usar una NIM prediseñada para implementar modelos de IA en producción en GKE de forma más rápida y sencilla.
Optimiza el rendimiento en las GPUs de NVIDIA: Obtén experiencia práctica con la implementación de NIM que usa NVIDIA TensorRT para la inferencia optimizada en las GPUs de tu clúster de GKE.
Escala las cargas de trabajo de inferencia de Scale AI: Explora cómo escalar tu implementación de NIM según la demanda con Kubernetes para el ajuste de escala automático y la administración de recursos de procesamiento.

2. Qué aprenderás

Al final de este instructivo, tendrás experiencia con lo siguiente:

Implementación de NIM en GKE: Implementa un NVIDIA NIM prediseñado para varias tareas de inferencia en tu clúster de GKE.
Administra las implementaciones de NIM: Usa comandos de kubectl para administrar, supervisar y escalar tu NIM implementado.
Escala las cargas de trabajo de inferencia: Utiliza las funciones de Kubernetes para ajustar automáticamente la escala de tus implementaciones de NIM según las demandas de tráfico.

3. Conoce los componentes

GPUs en Google Kubernetes Engine (GKE)

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 proporciona una variedad 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.

NVIDIA NIM

NVIDIA NIM es un conjunto de microservicios de inferencia fáciles de usar que aceleran la implementación de modelos básicos en cualquier nube o centro de datos, y ayudan a mantener la seguridad de tus datos.

NVIDIA AI Enterprise

NVIDIA AI Enterprise es una plataforma de software nativa de la nube y de extremo a extremo que acelera las canalizaciones de ciencia de datos y optimiza el desarrollo y la implementación de copilotos de nivel de producción y otras aplicaciones de IA generativa. Disponible a través de GCP Marketplace.

4. Requisitos previos

Proyecto: Un proyecto de Google Cloud con la facturación habilitada.
Permisos: Permisos suficientes para crear clústeres de GKE y otros recursos relacionados
Helm: Helm es un administrador de paquetes para Kubernetes.
Operador de GPU de NVIDIA: Es un complemento de Kubernetes que automatiza la administración de todos los componentes de software de NVIDIA necesarios para aprovisionar la GPU.
Clave de API de NVIDIA: Haz clic en este vínculo y sigue las instrucciones para crear una cuenta y generar una clave de API. Se requerirá una clave de API para descargar el contenedor de NIM.
GPUs de NVIDIA: Una de las siguientes GPUs debería funcionar (ten en cuenta que puedes seguir estos pasos para solicitar un aumento de la cuota si no tienes suficientes GPUs)
Opcional: SDK de gcloud: Si no usas Cloud Shell en el portal de GCP, asegúrate de tener instalado y configurado el SDK de Google Cloud.
Opcional: kubectl: En caso de que no uses Cloud Shell en el portal de GCP, asegúrate de tener instalada y configurada la herramienta de línea de comandos de kubectl.

5. Crea un clúster de GKE con GPUs

Abre Cloud Shell o tu terminal.

Especifica los siguientes parámetros:

export PROJECT_ID=<YOUR PROJECT ID>
export REGION=<YOUR REGION>
export ZONE=<YOUR ZONE>
export CLUSTER_NAME=nim-demo
export NODE_POOL_MACHINE_TYPE=g2-standard-16
export CLUSTER_MACHINE_TYPE=e2-standard-4
export GPU_TYPE=nvidia-l4
export GPU_COUNT=1

Ten en cuenta que es posible que debas cambiar los valores de NODE_POOL_MACHINE_TYPE, CLUSTER_MACHINE_TYPE y GPU_TYPE según el tipo de instancia de Compute y las GPUs que uses.

Crea un clúster de GKE:

gcloud container clusters create ${CLUSTER_NAME} \
    --project=${PROJECT_ID} \
    --location=${ZONE} \
    --release-channel=rapid \
    --machine-type=${CLUSTER_MACHINE_TYPE} \
    --num-nodes=1

Crea un grupo de nodos de GPU:

gcloud container node-pools create gpupool \
    --accelerator type=${GPU_TYPE},count=${GPU_COUNT},gpu-driver-version=latest \
    --project=${PROJECT_ID} \
    --location=${ZONE} \
    --cluster=${CLUSTER_NAME} \
    --machine-type=${NODE_POOL_MACHINE_TYPE} \
    --num-nodes=1

6. Configura la clave de API de NVIDIA NGC

La clave de la API de NGC te permite extraer imágenes personalizadas de NVIDIA NGC. Para especificar tu clave, haz lo siguiente:

export NGC_CLI_API_KEY="<YOUR NGC API KEY>"

Esta es la clave que se generó como parte de los requisitos previos.

7. Implementa y prueba NVIDIA NIM

Recupera el gráfico de Helm del LLM de NIM:

helm fetch https://helm.ngc.nvidia.com/nim/charts/nim-llm-1.3.0.tgz --username='$oauthtoken' --password=$NGC_CLI_API_KEY

Crea un espacio de nombres de NIM:
```
kubectl create namespace nim
```

Configura Secrets:

kubectl create secret docker-registry registry-secret --docker-server=nvcr.io --docker-username='$oauthtoken'     --docker-password=$NGC_CLI_API_KEY -n nim

kubectl create secret generic ngc-api --from-literal=NGC_API_KEY=$NGC_CLI_API_KEY -n nim

Configura NIM:

cat <<EOF > nim_custom_value.yaml
image:
  repository: "nvcr.io/nim/meta/llama3-8b-instruct" # container location
  tag: 1.0.0 # NIM version you want to deploy
model:
  ngcAPISecret: ngc-api  # name of a secret in the cluster that includes a key named NGC_CLI_API_KEY and is an NGC API key
persistence:
  enabled: true
imagePullSecrets:
  -   name: registry-secret # name of a secret used to pull nvcr.io images, see https://kubernetes.io/docs/tasks/    configure-pod-container/pull-image-private-registry/
EOF

Para iniciar la implementación de NIM, haz lo siguiente:

helm install my-nim nim-llm-1.1.2.tgz -f nim_custom_value.yaml --namespace nim

Verifica que el pod de NIM se esté ejecutando:

kubectl get pods -n nim

Prueba de la implementación del NIM:
Una vez que verificamos que nuestro servicio de NIM se implementó correctamente, podemos realizar solicitudes de inferencia para ver qué tipo de comentarios recibiremos del servicio de NIM. Para ello, habilitamos el reenvío de puertos en el servicio para poder acceder al NIM desde nuestro host local en el puerto 8000:

kubectl port-forward service/my-nim-nim-llm 8000:8000 -n nim

A continuación, podemos abrir otra terminal o pestaña en Cloud Shell y probar la siguiente solicitud:

curl -X 'POST' \
  'http://localhost:8000/v1/chat/completions' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '{
  "messages": [
    {
      "content": "You are a polite and respectful chatbot helping people plan a vacation.",
      "role": "system"
    },
    {
      "content": "What should I do for a 4 day vacation in Spain?",
      "role": "user"
    }
  ],
  "model": "meta/llama3-8b-instruct",
  "max_tokens": 128,
  "top_p": 1,
  "n": 1,
  "stream": false,
  "stop": "\n",
  "frequency_penalty": 0.0
}'

Si obtienes una respuesta de chat del servicio de NIM, significa que el servicio funciona según lo previsto.

8. Limpieza

Borra el clúster de GKE:

gcloud container clusters delete $CLUSTER_NAME --zone=$ZONE

9. ¿Qué sigue?

Consulta los siguientes artículos para obtener más información: