KI-Modell mit NVIDIA NIM in GKE bereitstellen

1. Einführung

In diesem Codelab erfahren Sie, wie Sie ein containerisiertes KI-Modell in Google Kubernetes Engine (GKE) bereitstellen und verwalten. Dabei nutzen Sie die Leistungsfähigkeit von NVIDIA NIM™-Mikrodiensten.

Diese Anleitung richtet sich an Entwickler und Data Scientists, die Folgendes tun möchten:

  • KI-Inferenzbereitstellung vereinfachen: Hier erfahren Sie, wie Sie ein vorgefertigtes NIM verwenden, um KI-Modelle schneller und einfacher in der Produktion in GKE bereitzustellen.
  • Leistung auf NVIDIA-GPUs optimieren: Sie erhalten praktische Erfahrung mit der Bereitstellung von NIMs, die NVIDIA TensorRT für optimierte Inferenz auf GPUs in Ihrem GKE-Cluster verwenden.
  • KI-Inferenzarbeitslasten skalieren: Hier erfahren Sie, wie Sie Ihre NIM-Bereitstellung bedarfsabhängig skalieren können, indem Sie Kubernetes für das Autoscaling und die Verwaltung von Rechenressourcen verwenden.

2. Lerninhalte

Am Ende dieser Anleitung haben Sie Folgendes gelernt:

  1. NIM in GKE bereitstellen: Stellen Sie ein vorgefertigtes NVIDIA NIM für verschiedene Inferenzaufgaben in Ihrem GKE-Cluster bereit.
  2. NIM-Deployments verwalten: Verwenden Sie kubectl-Befehle, um Ihre bereitgestellten NIMs zu verwalten, zu überwachen und zu skalieren.
  3. Inferenzarbeitslasten skalieren: Nutzen Sie Kubernetes-Funktionen, um Ihre NIM-Bereitstellungen basierend auf den Traffic-Anforderungen automatisch zu skalieren.

3. Komponenten kennenlernen

GPUs in Google Kubernetes Engine (GKE)

Mit GPUs können Sie bestimmte Arbeitslasten wie maschinelles Lernen und Datenverarbeitung beschleunigen, die auf Ihren Knoten ausgeführt werden. GKE bietet eine Reihe von Maschinentypoptionen für die Knotenkonfiguration, einschließlich Maschinentypen mit NVIDIA H100-, L4- und A100-GPUs.

NVIDIA NIM

NVIDIA NIM sind eine Reihe benutzerfreundlicher Inferenz-Mikrodienste, mit denen die Bereitstellung von Foundation Models in jeder Cloud oder jedem Rechenzentrum beschleunigt und Ihre Daten geschützt werden können.

NVIDIA AI Enterprise

NVIDIA AI Enterprise ist eine cloudnative End-to-End-Softwareplattform, die Data-Science-Pipelines beschleunigt und die Entwicklung und Bereitstellung von Copiloten in Produktionsqualität und anderen generativen KI-Anwendungen optimiert. Über den GCP Marketplace verfügbar.

4. Vorbereitung

  • Projekt:Ein Google Cloud-Projekt mit aktivierter Abrechnung.
  • Berechtigungen:Ausreichende Berechtigungen zum Erstellen von GKE-Clustern und anderen zugehörigen Ressourcen.
  • Helm:Helm ist ein Paketmanager für Kubernetes.
  • NVIDIA GPU-Operator:Ein Kubernetes-Add-on, das die Verwaltung aller NVIDIA-Softwarekomponenten automatisiert, die für die Bereitstellung von GPUs erforderlich sind.
  • NVIDIA-API-Schlüssel:Klicken Sie auf diesen Link und folgen Sie der Anleitung zum Erstellen eines Kontos und zum Generieren eines API-Schlüssels. Zum Herunterladen des NIM-Containers ist ein API-Schlüssel erforderlich.
  • NVIDIA-GPUs:Eine der folgenden GPUs sollte funktionieren. Wenn Sie nicht genügend GPUs haben, können Sie diese Schritte ausführen, um eine Kontingenterhöhung anzufordern.
  • Optional: GCloud SDK: Wenn Sie die Cloud Shell im GCP-Portal nicht verwenden, müssen Sie das Google Cloud SDK installieren und konfigurieren.
  • Optional – kubectl: Wenn Sie die Cloud Shell im GCP-Portal nicht verwenden, müssen Sie das kubectl-Befehlszeilentool installieren und konfigurieren.

5. GKE-Cluster mit GPUs erstellen

  1. Öffnen Sie die Cloud Shell oder Ihr Terminal.
  2. Geben Sie folgenden Parameter an:
    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

Hinweis: Möglicherweise müssen Sie die Werte für NODE_POOL_MACHINE_TYPE, CLUSTER_MACHINE_TYPE und GPU_TYPE ändern, je nachdem, welchen Typ von Compute-Instanz und GPUs Sie verwenden.

  1. GKE-Cluster erstellen:
    gcloud container clusters create ${CLUSTER_NAME} \
    --project=${PROJECT_ID} \
    --location=${ZONE} \
    --release-channel=rapid \
    --machine-type=${CLUSTER_MACHINE_TYPE} \
    --num-nodes=1
  2. GPU-Knotenpool erstellen:
    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. NVIDIA NGC API-Schlüssel konfigurieren

Mit dem NGC API-Schlüssel können Sie benutzerdefinierte Images aus NVIDIA NGC abrufen. So geben Sie Ihren Schlüssel an:

export NGC_CLI_API_KEY="<YOUR NGC API KEY>"

Dies ist der Schlüssel, der im Rahmen der Voraussetzungen generiert wurde.

7. NVIDIA NIM bereitstellen und testen

  1. NIM LLM-Helm-Diagramm abrufen:
    helm fetch https://helm.ngc.nvidia.com/nim/charts/nim-llm-1.3.0.tgz --username='$oauthtoken' --password=$NGC_CLI_API_KEY
  2. NIM-Namespace erstellen:
    kubectl create namespace nim
  3. Secrets konfigurieren:
    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. NIM-Konfiguration einrichten:
    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. NIM-Bereitstellung starten:
    helm install my-nim nim-llm-1.1.2.tgz -f nim_custom_value.yaml --namespace nim
    Prüfen Sie, ob der NIM-Pod ausgeführt wird:
    kubectl get pods -n nim
  6. NIM-Bereitstellung testen
    :Nachdem wir bestätigt haben, dass unser NIM-Dienst erfolgreich bereitgestellt wurde, können wir Inferenzanfragen stellen, um zu sehen, welche Art von Feedback wir vom NIM-Dienst erhalten. Dazu aktivieren wir die Portweiterleitung für den Dienst, damit wir über unseren Localhost auf Port 8000 auf das NIM zugreifen können:
    kubectl port-forward service/my-nim-nim-llm 8000:8000 -n nim
    Als Nächstes können wir ein weiteres Terminal oder einen weiteren Tab in der Cloud Shell öffnen und die folgende Anfrage ausprobieren:
    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
}'
    Wenn Sie eine Chat-Vervollständigung vom NIM-Dienst erhalten, funktioniert der Dienst wie erwartet.

8. Bereinigen

Löschen Sie den GKE-Cluster:

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

9. Nächste Schritte

Weitere Informationen finden Sie in den folgenden Artikeln: