Wdrażanie modelu AI w GKE za pomocą NVIDIA NIM

1. Wprowadzenie

Ten praktyczny przewodnik Codelab przeprowadzi Cię przez proces wdrażania skonteneryzowanego modelu AI w Google Kubernetes Engine (GKE) i zarządzania nim przy użyciu mikroserwisów NVIDIA NIM™.

Ten samouczek jest przeznaczony dla programistów i analityków danych, którzy chcą:

  • Uprość wdrażanie wnioskowania AI: dowiedz się, jak używać gotowego NIM do szybszego i łatwiejszego wdrażania modeli AI w środowisku produkcyjnym w GKE.
  • Optymalizacja wydajności na procesorach GPU NVIDIA: zdobądź praktyczne doświadczenie we wdrażaniu NIM, które korzystają z NVIDIA TensorRT w celu zoptymalizowanego wnioskowania na procesorach GPU w klastrze GKE.
  • Skalowanie zadań wnioskowania AI: dowiedz się, jak skalować wdrożenie NIM w zależności od zapotrzebowania, korzystając z Kubernetes do autoskalowania i zarządzania zasobami obliczeniowymi.

2. Czego się nauczysz

Po ukończeniu tego samouczka będziesz mieć doświadczenie w tych obszarach:

  1. Wdrażanie NIM w GKE: wdrażaj gotowe modele NVIDIA NIM do różnych zadań wnioskowania w klastrze GKE.
  2. Zarządzanie wdrożeniami NIM: używaj poleceń kubectl do zarządzania wdrożonymi modelami NIM, monitorowania ich i skalowania.
  3. Skalowanie zadań wnioskowania: korzystaj z funkcji Kubernetes do automatycznego skalowania wdrożeń NIM na podstawie zapotrzebowania na ruch.

3. Poznaj komponenty

GPU w Google Kubernetes Engine (GKE)

Procesory graficzne umożliwiają przyspieszenie wykonywania określonych zadań na węzłach, takich jak działania systemów uczących się i przetwarzanie danych. GKE udostępnia szereg opcji typów maszyn do konfiguracji węzłów, w tym typy maszyn z GPU NVIDIA H100, L4 i A100.

NVIDIA NIM

NVIDIA NIM to zestaw łatwych w użyciu mikrousług wnioskowania, które przyspieszają wdrażanie modeli podstawowych w dowolnej chmurze lub centrum danych i pomagają chronić Twoje dane.

NVIDIA AI Enterprise

NVIDIA AI Enterprise to kompleksowa platforma oprogramowania natywnego dla chmury, która przyspiesza potoki nauki o danych oraz usprawnia tworzenie i wdrażanie kopilotów klasy produkcyjnej i innych aplikacji generatywnej AI. Dostępne w GCP Marketplace.

4. Wymagania wstępne

  • Projekt: projekt Google Cloud z włączonymi płatnościami.
  • Uprawnienia: wystarczające uprawnienia do tworzenia klastrów GKE i innych powiązanych zasobów.
  • Helm: Helm to menedżer pakietów dla Kubernetes.
  • Operator GPU NVIDIA: dodatek do Kubernetes, który automatyzuje zarządzanie wszystkimi komponentami oprogramowania NVIDIA potrzebnymi do udostępniania GPU.
  • Klucz interfejsu API NVIDIA: kliknij ten link i postępuj zgodnie z instrukcjami, aby utworzyć konto i wygenerować klucz interfejsu API. Do pobrania kontenera NIM wymagany będzie klucz interfejsu API.
  • Procesory graficzne NVIDIA: powinien działać jeden z tych procesorów graficznych (pamiętaj, że jeśli nie masz wystarczającej liczby procesorów graficznych, możesz wykonać te czynności, aby poprosić o zwiększenie limitu).
  • Opcjonalnie – pakiet SDK GCloud: jeśli nie używasz Cloud Shell w portalu GCP, zainstaluj i skonfiguruj pakiet SDK Google Cloud.
  • Opcjonalnie – kubectl: jeśli nie używasz Cloud Shell w portalu GCP, upewnij się, że masz zainstalowane i skonfigurowane narzędzie wiersza poleceń kubectl.

5. Tworzenie klastra GKE z procesorami GPU

  1. Otwórz Cloud Shell lub terminal.
  2. Określ te parametry:
    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

Pamiętaj, że w zależności od typu instancji obliczeniowej i używanych procesorów graficznych może być konieczna zmiana wartości NODE_POOL_MACHINE_TYPE, CLUSTER_MACHINE_TYPE i GPU_TYPE.

  1. Utwórz klaster GKE:
    gcloud container clusters create ${CLUSTER_NAME} \
    --project=${PROJECT_ID} \
    --location=${ZONE} \
    --release-channel=rapid \
    --machine-type=${CLUSTER_MACHINE_TYPE} \
    --num-nodes=1
  2. Utwórz pulę węzłów 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. Konfigurowanie klucza interfejsu API NVIDIA NGC

Klucz interfejsu NGC API umożliwia pobieranie niestandardowych obrazów z NVIDIA NGC. Aby określić klucz:

export NGC_CLI_API_KEY="<YOUR NGC API KEY>"

Jest to klucz wygenerowany w ramach wymagań wstępnych.

7. Wdrażanie i testowanie NVIDIA NIM

  1. Pobierz wykres Helm NIM LLM:
    helm fetch https://helm.ngc.nvidia.com/nim/charts/nim-llm-1.3.0.tgz --username='$oauthtoken' --password=$NGC_CLI_API_KEY
  2. Utwórz przestrzeń nazw NIM:
    kubectl create namespace nim
  3. Skonfiguruj obiekty tajne:
    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. Konfigurowanie 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. Uruchamianie wdrożenia NIM:
    helm install my-nim nim-llm-1.1.2.tgz -f nim_custom_value.yaml --namespace nim
    Sprawdź, czy pod NIM jest uruchomiony:
    kubectl get pods -n nim
  6. Testowanie wdrożenia NIM:
    gdy potwierdzimy, że usługa NIM została wdrożona prawidłowo, możemy wysyłać żądania wnioskowania, aby sprawdzić, jakiego rodzaju opinie będziemy otrzymywać z usługi NIM. Aby to zrobić, włączamy przekierowanie portów w usłudze, aby uzyskać dostęp do NIM z naszego hosta lokalnego na porcie 8000:
    kubectl port-forward service/my-nim-nim-llm 8000:8000 -n nim
    Następnie możemy otworzyć kolejny terminal lub kartę w Cloud Shell i wypróbować to żądanie:
    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
}'
    Jeśli otrzymasz odpowiedź na czacie z usługi NIM, oznacza to, że działa ona prawidłowo.

8. Czyszczenie

Usuń klaster GKE:

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

9. Co dalej?

Więcej informacji znajdziesz w tych artykułach: