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:

  • Simplifique a implantação da inferência de IA: aprenda a usar um NIM pré-criado para implantar modelos de IA em produção no GKE com mais rapidez e facilidade.
  • Otimize o desempenho 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 sua 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:

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

3. Conheça os componentes

GPUs no Google Kubernetes Engine (GKE)

Com as GPUs, é possível acelerar cargas de trabalho específicas em execução nos nós, como machine learning e processamento de dados. O GKE oferece uma variedade 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

Os NVIDIA NIMs são 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 completa e nativa da nuvem que acelera os 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: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 neste link e siga as instruções para 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. Siga estas etapas para solicitar um aumento de cota se você não tiver GPUs suficientes.
  • Opcional: SDK gcloud: se você não estiver usando o Cloud Shell no portal do GCP, verifique se o SDK do Google Cloud está instalado e configurado.
  • Opcional: kubectl: se você não estiver 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

  1. Abra o Cloud Shell ou seu terminal.
  2. 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 GPUs que você está usando.

  1. Crie um 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
  2. Crie 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>"

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

7. Implantar e testar o NVIDIA NIM

  1. Buscar gráfico do Helm do LLM NIM:
    helm fetch https://helm.ngc.nvidia.com/nim/charts/nim-llm-1.3.0.tgz --username='$oauthtoken' --password=$NGC_CLI_API_KEY
  2. Crie um namespace do NIM:
    kubectl create namespace nim
  3. Configure 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
  4. 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
  5. Início da 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
  6. Teste da implantação do NIM
    :depois de verificar se o serviço de NIM foi implantado corretamente, podemos fazer solicitações de inferência para ver que tipo de feedback vamos receber do serviço. Para fazer isso, ative o encaminhamento de portas 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, abra outro terminal ou guia no Cloud Shell e tente 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 NIM, isso significa que ele está funcionando conforme o esperado.

8. Limpeza

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: