Implantar um modelo de IA no GKE com o NVIDIA NIM

1. Introdução

Este codelab prático vai orientar você na implantação e no gerenciamento de um modelo de IA em contêineres no Google Kubernetes Engine (GKE), usando o poder dos microsserviços NVIDIA NIM™.

Este tutorial foi criado para desenvolvedores e cientistas de dados que querem:

Simplificar a implantação da inferência de IA: aprenda a usar um NIM pré-criado para uma implantação mais rápida e fácil de modelos de IA na produção no GKE.
Otimizar a performance em GPUs NVIDIA: ganhe experiência prática com a implantação de NIMs que usam o NVIDIA TensorRT para inferência otimizada em GPUs no cluster do GKE.
Escalonar cargas de trabalho de inferência de IA: saiba como escalonar a implantação do NIM com base na demanda usando o Kubernetes para escalonamento automático e gerenciamento de recursos de computação.

2. O que você vai aprender

Ao final deste tutorial, você terá experiência com:

Implantação do NIM no GKE: implante um NIM NVIDIA pré-criado para várias tarefas de inferência no cluster do GKE.
Gerenciamento de implantações do NIM: use comandos kubectl para gerenciar, monitorar e escalonar o NIM implantado.
Escalonamento de cargas de trabalho de inferência: use os recursos do Kubernetes para escalonar automaticamente as implantações do NIM com base nas demandas de tráfego.

3. Conheça os componentes

GPUs no Google Kubernetes Engine (GKE)

As GPUs permitem acelerar cargas de trabalho específicas em execução nos nós, como machine learning e processamento de dados. O GKE oferece uma gama de opções de tipos de máquina para configuração de nós, incluindo tipos de máquinas com GPUs NVIDIA H100, L4 e A100.

NVIDIA NIM

O NVIDIA NIM é um conjunto de microsserviços de inferência fáceis de usar para acelerar a implantação de modelos de base em qualquer nuvem ou data center e ajudar a manter seus dados seguros.

NVIDIA AI Enterprise

O NVIDIA AI Enterprise é uma plataforma de software nativa da nuvem de ponta a ponta que acelera pipelines de ciência de dados e simplifica o desenvolvimento e a implantação de copilotos de nível de produção e outros aplicativos de IA generativa. Disponível no GCP Marketplace.

4. Pré-requisitos

Projeto na nuvem:um projeto do Google Cloud com o faturamento ativado.
Permissões:permissões suficientes para criar clusters do GKE e outros recursos relacionados.
Helm: o Helm é um gerenciador de pacotes para o Kubernetes.
Operador de GPU NVIDIA: um complemento do Kubernetes que automatiza o gerenciamento de todos os componentes de software da NVIDIA necessários para provisionar a GPU.
Chave de API da NVIDIA:clique em este link e siga as instruções sobre como criar uma conta e gerar uma chave de API. Uma chave de API será necessária para fazer o download do contêiner do NIM.
GPUs NVIDIA: uma das GPUs abaixo deve funcionar. (Se você não tiver GPUs suficientes, siga estas etapas para solicitar um aumento de cota)
Opcional - SDK do GCloud: caso não esteja usando o Cloud Shell no portal do GCP, verifique se o SDK Google Cloud está instalado e configurado.
Opcional - kubectl: caso não esteja usando o Cloud Shell no portal do GCP, verifique se a ferramenta de linha de comando kubectl está instalada e configurada.

5. Criar um cluster do GKE com GPUs

Abra o Cloud Shell ou seu terminal.

Especifique os parâmetros a seguir:

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

Talvez seja necessário mudar os valores de NODE_POOL_MACHINE_TYPE, CLUSTER_MACHINE_TYPE e GPU_TYPE com base no tipo de instância de computação e nas GPUs que você está usando.

Criar cluster do GKE:

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

Criar um pool de nós 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. Configurar a chave de API do NVIDIA NGC

A chave de API do NGC permite extrair imagens personalizadas do NVIDIA NGC. Para especificar sua chave:

export NGC_CLI_API_KEY="<YOUR NGC API KEY>"

Essa é a chave gerada como parte dos pré-requisitos.

7. Implantar e testar o NVIDIA NIM

Buscar o gráfico do Helm do LLM do NIM:

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

Criar um namespace do NIM:
```
kubectl create namespace nim
```

Configurar 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

Configurar o 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

Iniciar a implantação do NIM:

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

Verifique se o pod do NIM está em execução:

kubectl get pods -n nim

Testar a implantação do NIM:
Depois de verificar se o serviço do NIM foi implantado com sucesso, podemos fazer solicitações de inferência para ver que tipo de feedback vamos receber do serviço do NIM. Para fazer isso, ativamos o encaminhamento de porta no serviço para acessar o NIM do localhost na porta 8000:

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

Em seguida, podemos abrir outro terminal ou guia no Cloud Shell e tentar a seguinte solicitação:

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
}'

Se você receber uma conclusão de chat do serviço do NIM, isso significa que o serviço está funcionando conforme o esperado.

8. Revisão dos dados

Exclua o cluster do GKE:

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

9. A seguir

Confira os artigos a seguir para mais informações:

Implantar um modelo de IA no GKE com o NVIDIA NIM Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.