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

1. Wprowadzenie

W tym praktycznym ćwiczeniu pokażemy, jak wdrożyć skonteneryzowany model AI w Google Kubernetes Engine (GKE) i nim zarządzać przy użyciu mikrousług NVIDIA NIM™.

Ten samouczek jest przeznaczony dla programistów i specjalistów ds. analizy danych, którzy chcą:

  • uprościć wdrażanie wnioskowania AI: dowiedzieć się, jak używać gotowego NIM do szybszego i łatwiejszego wdrażania modeli AI w środowisku produkcyjnym w GKE;
  • zoptymalizować wydajność na procesorach graficznych NVIDIA: zdobyć praktyczne doświadczenie w wdrażaniu NIM, które używają NVIDIA TensorRT do zoptymalizowanego wnioskowania na procesorach graficznych w klastrze GKE;
  • skalować zbiory zadań wnioskowania AI: dowiedzieć się, jak skalować wdrożenie NIM na podstawie zapotrzebowania przy użyciu Kubernetes do autoskalowania i zarządzania zasobami obliczeniowymi.

2. Czego się nauczysz

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

  1. wdrażaniu NIM w GKE: wdrożysz gotowy NVIDIA NIM do różnych zadań wnioskowania w klastrze GKE;
  2. zarządzaniu wdrożeniami NIM: użyjesz poleceń kubectl do zarządzania wdrożonym NIM, jego monitorowania i skalowania;
  3. skalowaniu zbiorów zadań wnioskowania: wykorzystasz funkcje Kubernetes do autoskalowania wdrożeń NIM na podstawie zapotrzebowania na ruch.

3. Poznaj komponenty

Procesory graficzne w Google Kubernetes Engine (GKE)

Procesory graficzne umożliwiają przyspieszenie wykonywania określonych zbiorów zadań na węzłach, takich jak uczenie maszynowe i przetwarzanie danych. GKE oferuje szereg opcji typów maszyn do konfiguracji węzłów, w tym typy maszyn z procesorami graficznymi 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ć dane.

NVIDIA AI Enterprise

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

4. Wymagania wstępne

  • Projekt: projekt Google Cloud z włączonym rozliczeniem.
  • 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ępnienia GPU.
  • Klucz interfejsu API NVIDIA: kliknij ten link i postępuj zgodnie z instrukcjami, jak utworzyć konto i wygenerować klucz interfejsu API. Do pobrania kontenera NIM będzie potrzebny klucz interfejsu API.
  • Procesory graficzne NVIDIA: powinien działać co najmniej 1 z tych procesorów graficznych (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, zainstaluj i skonfiguruj narzędzie wiersza poleceń kubectl.

5. Utwórz klaster GKE z procesorami graficznymi

  1. Otwórz Cloud Shell lub terminal.
  2. Podaj 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ć konieczne zmodyfikowanie 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. Skonfiguruj klucz interfejsu API NVIDIA NGC

Klucz interfejsu API NGC 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. Wdróż i przetestuj 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. Skonfiguruj 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. Uruchom wdrożenie 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 sprawdzimy, że usługa NIM została wdrożona, możemy wysyłać żądania wnioskowania, aby sprawdzić, jakie opinie otrzymamy od usługi NIM. Aby to zrobić, włączamy przekierowanie portów w usłudze, aby móc uzyskać dostęp do NIM z hosta lokalnego na porcie 8000:
    kubectl port-forward service/my-nim-nim-llm 8000:8000 -n nim
    Następnie możemy otworzyć inny 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ź z usługi NIM, oznacza to, że usługa działa zgodnie z oczekiwaniami.

8. Czyszczenie

Usuń klaster GKE:

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

9. Co dalej?

Więcej informacji znajdziesz w tych artykułach: