KI-Modell mit NVIDIA NIM in GKE bereitstellen

1. Einführung

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

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

Bereitstellung der KI-Inferenz 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 NIM, 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 nach Bedarf skalieren, indem Sie Kubernetes für Autoscaling und die Verwaltung von Compute-Ressourcen verwenden.

2. Lerninhalte

Nach Abschluss dieser Anleitung haben Sie Erfahrung mit Folgendem:

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

3. Komponenten

GPUs in Google Kubernetes Engine (GKE)

GPUs ermöglichen Ihnen die Beschleunigung bestimmter Arbeitslasten wie maschinelles Lernen und Datenverarbeitung, 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 ist eine Reihe von einfach zu verwendenden Inferenz-Microservices, mit denen Sie die Bereitstellung von Foundation-Modellen in jeder Cloud oder jedem Rechenzentrum beschleunigen und Ihre Daten schützen 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:Google Cloud-Projekt mit aktivierter Abrechnungsfunktion.
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. Ein API-Schlüssel ist erforderlich, um den NIM-Container herunterzuladen.
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 zu beantragen.)
Optional - GCloud SDK:** Wenn Sie die Cloud Shell im GCP-Portal nicht verwenden, müssen Sie das Google Cloud SDK installiert und konfiguriert haben.
Optional - kubectl:** Wenn Sie die Cloud Shell im GCP-Portal nicht verwenden, müssen Sie das Befehlszeilentool kubectl installiert und konfiguriert haben.

5. GKE-Cluster mit GPUs erstellen

Öffnen Sie die Cloud Shell oder Ihr Terminal.

Geben Sie folgende 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 entsprechend dem Typ der Compute-Instanz und der GPUs ändern, die Sie verwenden.

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

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

Helm-Diagramm für NIM-LLM abrufen:

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

NIM-Namespace erstellen:
```
kubectl create namespace nim
```

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

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

NIM-Bereitstellung starten:

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

Prüfen, ob der NIM-Pod ausgeführt wird:

kubectl get pods -n nim

NIM-Bereitstellung testen:
Nachdem wir geprüft haben, ob unser NIM-Dienst erfolgreich bereitgestellt wurde, können wir Inferenzanfragen senden, 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 anderes Terminal oder einen anderen Tab in der Cloud Shell öffnen und die folgende Anfrage senden:

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:

KI-Modell mit NVIDIA NIM in GKE bereitstellen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.