Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Qwen3.8-2.4T in der GKE mit PD-Disaggregation auf mehreren Hosts mithilfe von Dynamo und SGLang auf A4-VMs bereitstellen

Geclusterte GPUs

In dieser Anleitung erfahren Sie, wie Sie Qwen3.8-2.4T (nvidia/Qwen3.8-2.4T-A95B-NVFP4), ein Mixture-of-Experts-Modell mit 2,4 Billionen Parametern und 95 Milliarden aktiven Parametern, die auf NVFP4 quantisiert sind, in Google Kubernetes Engine (GKE) aufGoogle Cloudbereitstellen und bereitstellen. Für die Bereitstellung werden das Cluster Toolkit, vier Multi-Host-A4-VM-Instanzen (a4-highgpu-8g) mit insgesamt 32 NVIDIA B200-GPUs, NVIDIA Dynamo und das SGLang-Serving-Framework mit Prefill-Decode-Disaggregation (PD) verwendet.

In der in dieser Anleitung beschriebenen Bereitstellungskonfiguration verwenden Sie das Cluster Toolkit, um einen GKE-Cluster im Standardmodus bereitzustellen. Der Cluster enthält vier a4-highgpu-8g-Knoten, die über ein GPUDirect-RDMA-Netzwerk (Remote Direct Memory Access) verbunden sind. Anschließend installieren Sie den KAI-Scheduler und die NVIDIA Dynamo-Plattform mit Grove-Gang-Scheduling und stellen die Modellgewichtungen in Cloud Storage bereit. Als Nächstes stellen Sie eine benutzerdefinierte DynamoGraphDeployment-Ressource bereit, die den Bucket mit Cloud Storage FUSE bereitstellt und Prefill und Decode auf zwei Multi-Host-Worker-Pools mit 16 GPUs mit Tensor-Parallelität, Experten-Parallelität und einem FP8-KV-Cache aufteilt.

Ziele

Cluster Toolkit installieren und einen GKE-Cluster mit mehreren Hosts im Standardmodus bereitstellen.
Installieren Sie den KAI-Scheduler und die NVIDIA Dynamo-Plattform mit Grove-Gang-Scheduling auf Ihrem Cluster.
Stellen Sie die Qwen3.8-2.4T-Modellgewichtungen in einem Cloud Storage-Bucket bereit.
Stellen Sie einen SGLang-Inferenzserver mit mehreren Hosts und disaggregierten nichtflüchtigen Speichern auf vier A4-Knoten mit insgesamt 32 NVIDIA B200-GPUs bereit.
Senden Sie eine Anfrage zur Chat-Vervollständigung an den Dynamo-Frontend-Router.
Führen Sie eine Benchmark-Arbeitslast für die Bereitstellung aus.
Bereinigen Sie die bereitgestellten Ressourcen.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten vonGoogle Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung Ihrer voraussichtlichen Nutzung vornehmen.

Hinweis

Richten Sie die Umgebung für die Anleitung ein:

Installieren und initialisieren Sie die Google Cloud CLI und installieren Sie kubectl und Helm (Version 3.10 oder höher). Wenn Sie Cloud Shell verwenden, sind diese Tools vorinstalliert.
Wenn Sie diese Anleitung auf einer Linux- oder macOS-Workstation statt in Cloud Shell ausführen, installieren Sie die erforderlichen Cluster Toolkit-Abhängigkeiten wie Terraform und Git.
Aktivieren Sie die Kubernetes Engine API, die Compute Engine API, die Cloud Storage API, die Identity and Access Management API, die Cloud Resource Manager API und die Service Usage API in Ihrem Google Cloud -Projekt:

APIs aktivieren

Hugging Face-Zugriffstoken abrufen

Für diese Anleitung benötigen Sie ein Hugging Face-Zugriffstoken. Sie können sich bei Hugging Face für ein kostenloses Konto registrieren. Nachdem Sie ein Konto erstellt haben, generieren Sie ein Zugriffstoken:

Klicken Sie auf der Seite Willkommen bei Hugging Face auf Ihren Konto-Avatar und wählen Sie Zugriffstokens aus.
Klicken Sie auf der Seite Zugriffstokens auf Neues Token erstellen.
Wählen Sie den Tokentyp Lesen aus und geben Sie einen Namen für das Token ein.
Ihr Zugriffstoken wird angezeigt. Speichern Sie das Token an einem sicheren Ort.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ausführen dieser Anleitung benötigen:

Kubernetes Engine-Administrator (roles/container.admin)
Compute-Administrator (roles/compute.admin)
Storage-Administrator (roles/storage.admin)
Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin)
Service Account Admin (roles/iam.serviceAccountAdmin)
Service Account User (roles/iam.serviceAccountUser)
Service Usage Consumer (roles/serviceusage.serviceUsageConsumer)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Umgebungsvariablen einrichten

Exportieren Sie die Umgebungsvariablen, die Sie in dieser Anleitung verwenden:

export PROJECT_ID="YOUR_PROJECT_ID"
export REGION="YOUR_REGION"
export ZONE="YOUR_ZONE"
export CLUSTER_NAME="YOUR_CLUSTER_NAME"
export RESERVATION_NAME="YOUR_RESERVATION_NAME"
export GCS_BUCKET="YOUR_BUCKET_NAME"
export HF_TOKEN="YOUR_HF_TOKEN"
export CLUSTER_TOOLKIT_VERSION="v1.104.0"
export DYNAMO_RELEASE_VERSION="1.5.0"

gcloud config set project "${PROJECT_ID}"
gcloud config set billing/quota_project "${PROJECT_ID}"

Ersetzen Sie Folgendes:

YOUR_PROJECT_ID: die ID Ihres Projekts in Google Cloud.
YOUR_REGION: die Region, in der sich Ihre A4-Kapazität befindet und in der Sie Ihren Cluster bereitstellen möchten, z. B. us-central1.
YOUR_ZONE: die Zone, in der sich Ihre A4-Kapazität befindet, z. B. us-central1-b.
YOUR_CLUSTER_NAME: der Name für Ihren GKE-Cluster und die Cluster Toolkit-Bereitstellung. Verwenden Sie einen Namen mit maximal 20 Zeichen, damit die generierte Dienstkonto-ID des Knotenpools (YOUR_CLUSTER_NAME-gke-np-sa) innerhalb des IAM-Limits (Identity and Access Management) von 30 Zeichen bleibt.
YOUR_RESERVATION_NAME: der Name Ihrer A4-Reservierung oder der Pfad des erweiterten Reservierungsblocks im Format RESERVATION_NAME/reservationBlocks/RESERVATION_BLOCK_NAME.
YOUR_BUCKET_NAME: ein global eindeutiger Name für den Cloud Storage-Bucket, in dem der Terraform-Status für das Cluster Toolkit und die bereitgestellten Qwen3.8-2.4T-Modellgewichtungen gespeichert werden.
YOUR_HF_TOKEN: Ihr Hugging Face-Zugriffstoken.

GKE-Cluster erstellen

Laden Sie das Cluster Toolkit herunter und stellen Sie einen GKE-Cluster im Standardmodus mit vier a4-highgpu-8g-Knoten, GPUDirect RDMA-Netzwerk und DRA-Unterstützung bereit:

Melden Sie sich in der Google Cloud CLI an und generieren Sie Standardanmeldedaten für Anwendungen für Terraform:
```
gcloud auth login
gcloud auth application-default login
```
Laden Sie das vordefinierte Cluster Toolkit-Bundle für die in CLUSTER_TOOLKIT_VERSION (v1.104.0) angegebene Version herunter und extrahieren Sie es:
```
TAG="${CLUSTER_TOOLKIT_VERSION:-v1.104.0}"
OS="linux"
ARCH="amd64"
mkdir -p cluster-toolkit && curl -L "https://github.com/GoogleCloudPlatform/cluster-toolkit/releases/download/${TAG}/gcluster_bundle_${OS}_${ARCH}.tgz" | tar -xz -C cluster-toolkit
```
Wenn Sie diesen Befehl unter macOS oder auf einer arm64-Workstation ausführen, legen Sie OS="mac" oder ARCH="arm64" entsprechend Ihrer Plattform fest.
Erstellen Sie einen Cloud Storage-Bucket in derselben Region wie Ihre A4-Reservierung mit einheitlichem Zugriff auf Bucket-Ebene und aktivierter Objektversionsverwaltung, um den Terraform-Zustand für Ihre Cluster Toolkit-Bereitstellung und die bereitgestellten Modellgewichtungen zu speichern:
```
gcloud storage buckets create "gs://${GCS_BUCKET}" \
    --default-storage-class=STANDARD \
    --project="${PROJECT_ID}" \
    --location="${REGION}" \
    --uniform-bucket-level-access
gcloud storage buckets update "gs://${GCS_BUCKET}" --versioning
```
Erstellen Sie die Bereitstellungskonfigurationsdatei cluster-toolkit/examples/gke-a4/gke-a4-deployment.yaml für vier a4-highgpu-8g-Knoten:
```
cat <<EOF > cluster-toolkit/examples/gke-a4/gke-a4-deployment.yaml
terraform_backend_defaults:
  type: gcs
  configuration:
    bucket: ${GCS_BUCKET}

vars:
  project_id: ${PROJECT_ID}
  deployment_name: ${CLUSTER_NAME}
  region: ${REGION}
  zone: ${ZONE}
  static_node_count: 4
  authorized_cidr: 0.0.0.0/0
  reservation_affinity:
    consume_reservation_type: SPECIFIC_RESERVATION
    specific_reservations:
    - name: ${RESERVATION_NAME}
EOF
```
Standardmäßig ist die Bereitstellungsdatei so konfiguriert, dass eine bestimmte Reservierung genutzt wird. Wenn Sie keine bestimmte Reservierung haben, können Sie vor dem Bereitstellen des Clusters cluster-toolkit/examples/gke-a4/gke-a4-deployment.yaml aktualisieren, um eine alternative Nutzungsoption wie Spot-VMs oder Flex-Start-VMs zu verwenden. Eine Konfigurationsanleitung finden Sie unter GKE-Nutzungsoptionen.
Wechseln Sie in das Verzeichnis cluster-toolkit, stellen Sie den GKE-Cluster mit dem Befehl gcluster deploy bereit und kehren Sie dann zu Ihrem Arbeitsverzeichnis zurück:
```
cd cluster-toolkit
./gcluster deploy \
    -d examples/gke-a4/gke-a4-deployment.yaml \
    examples/gke-a4/gke-a4.yaml \
    --auto-approve -w
cd ..
```
Die Erstellung eines Clusters dauert etwa 20 bis 30 Minuten. Wenn Sie ./gcluster deploy ohne das Flag --auto-approve ausführen, geben Sie a ein, wenn Sie dazu aufgefordert werden, um die vorgeschlagenen Änderungen anzuwenden.

Konfigurieren Sie kubectl-Anmeldedaten für die Kommunikation mit Ihrem Cluster:

gcloud container clusters get-credentials "${CLUSTER_NAME}" \
    --location="${REGION}" \
    --project="${PROJECT_ID}"

KAI Scheduler und NVIDIA Dynamo installieren

Bereiten Sie Ihren Cluster vor, indem Sie ein Hugging Face-Secret erstellen und den KAI-Scheduler und die NVIDIA Dynamo-Plattform mit Grove-Gang-Scheduling installieren:

Erstellen Sie ein Kubernetes-Secret mit dem Namen hf-secret, um Ihr Hugging Face-Zugriffstoken zu speichern:

kubectl create secret generic hf-secret \
    --from-literal=hf_api_token="${HF_TOKEN}" \
    --dry-run=client -o yaml | kubectl apply -f -

Laden Sie das Helm-Diagramm für die NVIDIA Dynamo-Plattform (v1.5.0) herunter, installieren Sie den KAI-Scheduler und installieren Sie die Dynamo-Plattform mit aktiviertem Grove:

RELEASE_VERSION="${DYNAMO_RELEASE_VERSION:-1.5.0}"
helm pull "https://helm.ngc.nvidia.com/nvidia/ai-dynamo/charts/dynamo-platform-${RELEASE_VERSION}.tgz"
tar -zxf "dynamo-platform-${RELEASE_VERSION}.tgz"

helm upgrade --install kai-scheduler ./dynamo-platform/charts/kai-scheduler \
    --set scheduler.args.default-staleness-grace-period="-1s" \
    --set topologyMigration.enabled=false

kubectl wait --for=condition=Available deployment/kai-operator --timeout=120s
until kubectl get deployment/queue-controller >/dev/null 2>&1; do sleep 2; done
kubectl wait --for=condition=Available deployment/queue-controller --timeout=120s

helm upgrade --install dynamo-platform ./dynamo-platform \
    --set global.grove.install=true \
    --set global.grove.enabled=true \
    --set global.kai-scheduler.enabled=true

Modellgewichtungen in Cloud Storage bereitstellen

Stellen Sie den nvidia/Qwen3.8-2.4T-A95B-NVFP4-Prüfpunkt in Ihrem Cloud Storage-Bucket (gs://${GCS_BUCKET}) in der Region bereit, damit die Inferenz-Worker-Pods die Gewichtungen mit Cloud Storage FUSE bereitstellen können, anstatt sie bei jedem Kaltstart von Hugging Face herunterzuladen:

Weisen Sie dem Google-Dienstkonto, das an das Kubernetes-Dienstkonto workload-identity-k8s-sa gebunden ist, die Rolle „Storage-Objekt-Nutzer“ (roles/storage.objectUser) für den Bucket gs://${GCS_BUCKET} zu, den Sie unter GKE-Cluster erstellen erstellt haben:

GSA=$(kubectl get sa workload-identity-k8s-sa -o jsonpath='{.metadata.annotations.iam\.gke\.io/gcp-service-account}')
gcloud storage buckets add-iam-policy-binding "gs://${GCS_BUCKET}" \
    --member="serviceAccount:${GSA}" \
    --role="roles/storage.objectUser"

Laden Sie die Manifeste qwen3.8-2.4t-nvfp4-stage-weights-job.yaml und qwen3.8-2.4t-nvfp4-multihost-a4-gcsfuse.yaml herunter:

curl -O https://raw.githubusercontent.com/GoogleCloudSamples/AIHypercomputerSamples/refs/heads/main/gpu/inference/qwen38-2t/qwen3.8-2.4t-nvfp4-stage-weights-job.yaml
curl -O https://raw.githubusercontent.com/GoogleCloudSamples/AIHypercomputerSamples/refs/heads/main/gpu/inference/qwen38-2t/qwen3.8-2.4t-nvfp4-multihost-a4-gcsfuse.yaml

Alternativ können Sie eine Datei mit dem Namen qwen3.8-2.4t-nvfp4-stage-weights-job.yaml und dem folgenden Inhalt erstellen. Dieser indexierte Job führt vier parallele Pods auf Ihren vier A4-Knoten aus. Jeder Pod lädt einen größenmäßig ausgewogenen Teil des nvidia/Qwen3.8-2.4T-A95B-NVFP4-Prüfpunkts auf die lokale NVMe-SSD des Knotens herunter und lädt ihn mit gcloud storage rsync in gs://${GCS_BUCKET}/hf_models/models--nvidia--qwen3_8-2_4t-a95b-nvfp4 hoch:

# ==============================================================================
# Stage nvidia/Qwen3.8-2.4T-A95B-NVFP4 (~1.44 TB, 210 files) from Hugging Face Hub
# into an in-region Cloud Storage bucket for qwen3.8-2.4t-nvfp4-multihost-a4-gcsfuse.yaml
#
# Each Indexed Job pod downloads a size-balanced slice of the repo onto the node's
# local NVMe SSD, then uploads that slice with `gcloud storage rsync`.
# ==============================================================================
apiVersion: batch/v1
kind: Job
metadata:
  name: qwen3-8-2-4t-stage-weights
spec:
  completionMode: Indexed
  completions: 4
  parallelism: 4
  backoffLimitPerIndex: 2
  template:
    metadata:
      labels:
        app: qwen3-8-2-4t-stage-weights
    spec:
      restartPolicy: Never
      serviceAccountName: workload-identity-k8s-sa
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-b200
      tolerations:
        - key: "nvidia.com/gpu"
          operator: "Exists"
          effect: "NoSchedule"
      topologySpreadConstraints:
        - maxSkew: 1
          topologyKey: kubernetes.io/hostname
          whenUnsatisfiable: DoNotSchedule
          labelSelector:
            matchLabels:
              app: qwen3-8-2-4t-stage-weights
      initContainers:
        - name: download
          image: nvcr.io/nvidia/ai-dynamo/sglang-runtime:1.5.0
          command: ["python3", "-c"]
          args:
            - |
              import os, time
              from huggingface_hub import HfApi, snapshot_download
              repo = os.environ["REPO_ID"]
              n = int(os.environ["NUM_SHARDS"])
              i = int(os.environ["JOB_COMPLETION_INDEX"])
              info = HfApi().model_info(repo, files_metadata=True)
              files = sorted(((s.size or 0, s.rfilename) for s in info.siblings), reverse=True)
              bins = [[0, []] for _ in range(n)]
              for size, name in files:
                  b = min(bins, key=lambda x: x[0])
                  b[0] += size
                  b[1].append(name)
              size, mine = bins[i]
              print(f"shard {i}/{n}: {len(mine)} files, {size / 1e9:.1f} GB", flush=True)
              for attempt in range(1, 7):
                  try:
                      snapshot_download(repo, local_dir="/ssd/model", allow_patterns=mine, max_workers=16)
                      break
                  except Exception as e:
                      print(f"shard {i}/{n}: attempt {attempt} failed: {e!r}", flush=True)
                      if attempt == 6:
                          raise
                      time.sleep(30)
              print(f"shard {i}/{n}: download complete", flush=True)
          env:
            - name: REPO_ID
              value: "nvidia/Qwen3.8-2.4T-A95B-NVFP4"
            - name: NUM_SHARDS
              value: "4"
            - name: HF_HOME
              value: "/ssd/hf"
            - name: HF_HUB_DISABLE_XET
              value: "1"
            - name: HF_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
                  optional: true
          resources:
            requests:
              cpu: "16"
              memory: "64Gi"
              ephemeral-storage: "450Gi"
            limits:
              cpu: "16"
              memory: "64Gi"
              ephemeral-storage: "700Gi"
          volumeMounts:
            - name: ssd
              mountPath: /ssd
      containers:
        - name: upload
          image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
          command: ["/bin/bash", "-c"]
          args:
            - |
              set -euo pipefail
              gcloud storage rsync --recursive --exclude='^\.cache/.*' /ssd/model "${DEST}"
              echo "shard ${JOB_COMPLETION_INDEX}: upload complete"
          env:
            - name: DEST
              value: "gs://${GCS_BUCKET}/hf_models/models--nvidia--qwen3_8-2_4t-a95b-nvfp4"
          resources:
            requests:
              cpu: "16"
              memory: "32Gi"
            limits:
              cpu: "16"
              memory: "32Gi"
          volumeMounts:
            - name: ssd
              mountPath: /ssd
      volumes:
        - name: ssd
          emptyDir: {}

Ersetzen Sie qwen3.8-2.4t-nvfp4-stage-weights-job.yaml durch den Namen Ihres Cloud Storage-Bucket, starten Sie den Staging-Job, warten Sie, bis alle vier Pods die Gewichtungen hochgeladen haben, und löschen Sie dann den abgeschlossenen Job:
```
envsubst '${GCS_BUCKET}' < qwen3.8-2.4t-nvfp4-stage-weights-job.yaml | kubectl apply -f -

kubectl wait --for=condition=complete job/qwen3-8-2-4t-stage-weights --timeout=2h

kubectl delete job qwen3-8-2-4t-stage-weights
```
Das Herunterladen der Modellgewichtungen auf die lokale NVMe-SSD und das Hochladen in Cloud Storage dauert etwa 25 Minuten.
Optional: Während der Staging-Job ausgeführt wird, können Sie die Logs eines Staging-Pods in einer zweiten Terminalsitzung streamen, um den Downloadfortschritt zu überwachen:
```
POD_NAME="YOUR_POD_NAME"
kubectl logs -f "${POD_NAME}"
```
Ersetzen Sie YOUR_POD_NAME durch den Namen eines der qwen3-8-2-4t-stage-weights-Pods aus kubectl get pods.

Disaggregierten SGLang-Server mit mehreren Hosts bereitstellen

Das Arbeitslastmanifest (qwen3.8-2.4t-nvfp4-multihost-a4-gcsfuse.yaml) definiert ein Kubernetes-ResourceClaimTemplate (all-mrdma), das die Multi-NIC-RDMA-Geräte (mrdma.google.com) des Knotens über DRA, Role- und RoleBinding-Ressourcen für das Dienstkonto workload-identity-k8s-sa und ein NVIDIA Dynamo DynamoGraphDeployment (qwen3-8-2-4t-a4-disagg) mit aktiviertem Grove-Gang-Scheduling zuweist. Die Bereitstellung umfasst Folgendes:

Frontend (Frontend): Führt ein Router-Replikat aus, das Clientanfragen akzeptiert, registrierte Prefill- und Decodierungs-Worker erkennt und das disaggregierte Anfragerouting koordiniert.
Prefill-Worker (Prefill): Führt einen Worker-Pool mit zwei Knoten auf zwei a4-highgpu-8g-Knoten mit insgesamt 16 NVIDIA B200-GPUs aus. Jeder Pod stellt die bereitgestellten nvidia/Qwen3.8-2.4T-A95B-NVFP4-Gewichtungen aus Ihrem Cloud Storage-Bucket unter /model-weights bereit. Dazu wird der Cloud Storage FUSE-CSI-Treiber (gcsfuse.csi.storage.gke.io) mit lokalem NVMe-SSD-Dateicaching verwendet, die NCCL/gIB-Umgebung wird als Quelle verwendet und python3 -m dynamo.sglang wird in --disaggregation-mode prefill mit den folgenden Flags gestartet:
- --served-model-name "nvidia/Qwen3.8-2.4T-A95B-NVFP4"
- --tensor-parallel-size 16
- --ep-size 16
- --nnodes 2
- --moe-runner-backend flashinfer_trtllm
- --attention-backend triton
- --kv-cache-dtype fp8_e4m3
- --disable-flashinfer-autotune
Decode-Worker (Decode): Führt einen Worker-Pool mit zwei Knoten auf den verbleibenden beiden a4-highgpu-8g-Knoten mit insgesamt 16 NVIDIA B200-GPUs aus. Jeder Pod stellt die bereitgestellten Modellgewichtungen aus Cloud Storage unter /model-weights über den Cloud Storage FUSE-CSI-Treiber bereit und startet python3 -m dynamo.sglang in --disaggregation-mode decode mit den folgenden Flags:
- --served-model-name "nvidia/Qwen3.8-2.4T-A95B-NVFP4"
- --tensor-parallel-size 16
- --ep-size 16
- --nnodes 2
- --moe-runner-backend flashinfer_trtllm
- --attention-backend triton
- --kv-cache-dtype fp8_e4m3

Disaggregierten Inferenzserver bereitstellen und überwachen:

Sehen Sie sich das zuvor heruntergeladene Arbeitslastmanifest qwen3.8-2.4t-nvfp4-multihost-a4-gcsfuse.yaml an oder erstellen Sie eine Datei mit dem Namen qwen3.8-2.4t-nvfp4-multihost-a4-gcsfuse.yaml und folgendem Inhalt:

# ==============================================================================
# Multihost Disaggregated Serving of Qwen3.8-2.4T-A95B (NVFP4 MoE) on GKE
# using NVIDIA Dynamo Platform (v1.5.0) and SGLang on GPU A4 (4 x a4-highgpu-8g)
# ==============================================================================
apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: all-mrdma
spec:
  spec:
    devices:
      requests:
        - name: req-mrdma
          exactly:
            deviceClassName: mrdma.google.com
            allocationMode: All
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: dynamo-workload-identity-discovery-role
  namespace: default
rules:
  - apiGroups: [""]
    resources: ["endpoints", "pods"]
    verbs: ["get", "list", "watch"]
  - apiGroups: ["discovery.k8s.io"]
    resources: ["endpointslices"]
    verbs: ["get", "list", "watch"]
  - apiGroups: ["nvidia.com"]
    resources: ["dynamoworkermetadatas"]
    verbs: ["create", "get", "list", "watch", "update", "patch", "delete"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: dynamo-workload-identity-discovery-binding
  namespace: default
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: dynamo-workload-identity-discovery-role
subjects:
  - kind: ServiceAccount
    name: workload-identity-k8s-sa
    namespace: default
---
apiVersion: nvidia.com/v1alpha1
kind: DynamoGraphDeployment
metadata:
  name: qwen3-8-2-4t-a4-disagg
  annotations:
    nvidia.com/enable-grove: "true"
spec:
  backendFramework: sglang
  services:
    # --------------------------------------------------------------------------
    # FRONTEND: Dynamo OpenAI-Compatible Router (`python3 -m dynamo.frontend`)
    # --------------------------------------------------------------------------
    Frontend:
      componentType: frontend
      replicas: 1
      resources:
        requests:
          cpu: "8"
          memory: "32Gi"
        limits:
          cpu: "8"
          memory: "32Gi"
      extraPodSpec:
        tolerations:
          - key: "nvidia.com/gpu"
            operator: "Exists"
            effect: "NoSchedule"
        mainContainer:
          image: nvcr.io/nvidia/ai-dynamo/sglang-runtime:1.5.0
          command: ["/bin/bash", "-c"]
          args:
            - |
              set -ex
              exec python3 -m dynamo.frontend --http-port 8000

    # --------------------------------------------------------------------------
    # PREFILL WORKER: 2 x GPU A4 (`a4-highgpu-8g`, 16 x B200 GPUs, TP=16, EP=16)
    # --------------------------------------------------------------------------
    Prefill:
      componentType: worker
      subComponentType: prefill
      replicas: 1
      multinode:
        nodeCount: 2
      extraPodMetadata:
        annotations:
          gke-gcsfuse/volumes: "true"
      livenessProbe:
        httpGet:
          path: /live
          port: system
        periodSeconds: 60
        timeoutSeconds: 30
        failureThreshold: 60
      readinessProbe:
        httpGet:
          path: /health
          port: system
        initialDelaySeconds: 120
        periodSeconds: 30
        timeoutSeconds: 30
        failureThreshold: 60
      sharedMemory:
        size: 128Gi
      resources:
        requests:
          gpu: "8"
          cpu: "128"
          memory: "1500Gi"
        limits:
          gpu: "8"
          cpu: "128"
          memory: "2000Gi"
      envs:
        - name: MODEL_PATH
          value: "/model-weights/hf_models/models--nvidia--qwen3_8-2_4t-a95b-nvfp4"
        - name: DYN_SYSTEM_PORT
          value: "9090"
        - name: LD_LIBRARY_PATH
          value: "/usr/local/gib/lib64:/usr/local/nvidia/lib64"
        - name: GLOO_SOCKET_IFNAME
          value: "eth0"
        - name: NCCL_ALGO
          value: "Ring,Tree"
        - name: WITH_NVIDIA_PEERMEM
          value: "0"
      extraPodSpec:
        serviceAccountName: workload-identity-k8s-sa
        automountServiceAccountToken: true
        resourceClaims:
          - name: rdma
            resourceClaimTemplateName: all-mrdma
        nodeSelector:
          cloud.google.com/gke-accelerator: nvidia-b200
        tolerations:
          - key: "nvidia.com/gpu"
            operator: "Exists"
            effect: "NoSchedule"
        mainContainer:
          image: nvcr.io/nvidia/ai-dynamo/sglang-runtime:1.5.0
          resources:
            claims:
              - name: rdma
          startupProbe:
            httpGet:
              path: /live
              port: system
            initialDelaySeconds: 120
            periodSeconds: 30
            timeoutSeconds: 10
            failureThreshold: 120
          command: ["/bin/bash", "-c"]
          args:
            - |
              set -ex
              if [ -f /usr/local/gib/scripts/set_nccl_env.sh ]; then
                . /usr/local/gib/scripts/set_nccl_env.sh
              fi

              echo "=== [Dynamo Prefill Worker] Launching dynamo.sglang ==="
              exec python3 -m dynamo.sglang \
                --dist-init-addr "${GROVE_PCSG_NAME}-${GROVE_PCSG_INDEX}-prefill-ldr-0.${GROVE_HEADLESS_SERVICE}.:29500" \
                --model-path "${MODEL_PATH}" \
                --served-model-name "nvidia/Qwen3.8-2.4T-A95B-NVFP4" \
                --host 0.0.0.0 \
                --disaggregation-mode prefill \
                --disaggregation-bootstrap-port 30001 \
                --tensor-parallel-size 16 \
                --ep-size 16 \
                --moe-runner-backend flashinfer_trtllm \
                --attention-backend triton \
                --disable-flashinfer-autotune \
                --nnodes 2 \
                --kv-cache-dtype fp8_e4m3 \
                --context-length 16384 \
                --mem-fraction-static 0.85 \
                --enable-metrics
          volumeMounts:
            - name: library-dir-host
              mountPath: /usr/local/nvidia
            - name: gib
              mountPath: /usr/local/gib
            - name: gcs-model-dir
              mountPath: /model-weights
              readOnly: true
        volumes:
          - name: library-dir-host
            hostPath:
              path: /home/kubernetes/bin/nvidia
          - name: gib
            hostPath:
              path: /home/kubernetes/bin/gib
          - name: gcs-model-dir
            csi:
              driver: gcsfuse.csi.storage.gke.io
              readOnly: true
              volumeAttributes:
                bucketName: ${GCS_BUCKET}
                mountOptions: "implicit-dirs,file-cache:max-size-mb:-1"

    # --------------------------------------------------------------------------
    # DECODE WORKER: 2 x GPU A4 (`a4-highgpu-8g`, 16 x B200 GPUs, TP=16, EP=16)
    # --------------------------------------------------------------------------
    Decode:
      componentType: worker
      subComponentType: decode
      replicas: 1
      multinode:
        nodeCount: 2
      extraPodMetadata:
        annotations:
          gke-gcsfuse/volumes: "true"
      livenessProbe:
        httpGet:
          path: /live
          port: system
        periodSeconds: 60
        timeoutSeconds: 30
        failureThreshold: 60
      readinessProbe:
        httpGet:
          path: /health
          port: system
        initialDelaySeconds: 120
        periodSeconds: 30
        timeoutSeconds: 30
        failureThreshold: 60
      sharedMemory:
        size: 128Gi
      resources:
        requests:
          gpu: "8"
          cpu: "128"
          memory: "1500Gi"
        limits:
          gpu: "8"
          cpu: "128"
          memory: "2000Gi"
      envs:
        - name: MODEL_PATH
          value: "/model-weights/hf_models/models--nvidia--qwen3_8-2_4t-a95b-nvfp4"
        - name: DYN_SYSTEM_PORT
          value: "9090"
        - name: LD_LIBRARY_PATH
          value: "/usr/local/gib/lib64:/usr/local/nvidia/lib64"
        - name: GLOO_SOCKET_IFNAME
          value: "eth0"
        - name: NCCL_ALGO
          value: "Ring,Tree"
        - name: WITH_NVIDIA_PEERMEM
          value: "0"
      extraPodSpec:
        serviceAccountName: workload-identity-k8s-sa
        automountServiceAccountToken: true
        resourceClaims:
          - name: rdma
            resourceClaimTemplateName: all-mrdma
        nodeSelector:
          cloud.google.com/gke-accelerator: nvidia-b200
        tolerations:
          - key: "nvidia.com/gpu"
            operator: "Exists"
            effect: "NoSchedule"
        mainContainer:
          image: nvcr.io/nvidia/ai-dynamo/sglang-runtime:1.5.0
          resources:
            claims:
              - name: rdma
          startupProbe:
            httpGet:
              path: /live
              port: system
            initialDelaySeconds: 120
            periodSeconds: 30
            timeoutSeconds: 10
            failureThreshold: 120
          command: ["/bin/bash", "-c"]
          args:
            - |
              set -ex
              if [ -f /usr/local/gib/scripts/set_nccl_env.sh ]; then
                . /usr/local/gib/scripts/set_nccl_env.sh
              fi

              echo "=== [Dynamo Decode Worker] Launching dynamo.sglang ==="
              exec python3 -m dynamo.sglang \
                --dist-init-addr "${GROVE_PCSG_NAME}-${GROVE_PCSG_INDEX}-decode-ldr-0.${GROVE_HEADLESS_SERVICE}.:29500" \
                --model-path "${MODEL_PATH}" \
                --served-model-name "nvidia/Qwen3.8-2.4T-A95B-NVFP4" \
                --host 0.0.0.0 \
                --disaggregation-mode decode \
                --disaggregation-bootstrap-port 30001 \
                --tensor-parallel-size 16 \
                --ep-size 16 \
                --moe-runner-backend flashinfer_trtllm \
                --attention-backend triton \
                --nnodes 2 \
                --kv-cache-dtype fp8_e4m3 \
                --context-length 16384 \
                --mem-fraction-static 0.85 \
                --enable-metrics
          volumeMounts:
            - name: library-dir-host
              mountPath: /usr/local/nvidia
            - name: gib
              mountPath: /usr/local/gib
            - name: gcs-model-dir
              mountPath: /model-weights
              readOnly: true
        volumes:
          - name: library-dir-host
            hostPath:
              path: /home/kubernetes/bin/nvidia
          - name: gib
            hostPath:
              path: /home/kubernetes/bin/gib
          - name: gcs-model-dir
            csi:
              driver: gcsfuse.csi.storage.gke.io
              readOnly: true
              volumeAttributes:
                bucketName: ${GCS_BUCKET}
                mountOptions: "implicit-dirs,file-cache:max-size-mb:-1"

Ersetzen Sie qwen3.8-2.4t-nvfp4-multihost-a4-gcsfuse.yaml durch den Namen Ihres Cloud Storage-Bucket und wenden Sie das Arbeitslastmanifest auf Ihren Cluster an:
```
envsubst '${GCS_BUCKET}' < qwen3.8-2.4t-nvfp4-multihost-a4-gcsfuse.yaml | kubectl apply -f -
```
Wenn Sie das Laden der Gewichtungen und die Serverinitialisierung überwachen möchten, listen Sie die Pods in Ihrem Cluster auf und streamen Sie die Logs des Prefill-Leader-Pods und des Decode-Leader-Pods:
```
kubectl get pods
POD_NAME="YOUR_POD_NAME"
kubectl logs -f "${POD_NAME}"
```
Ersetzen Sie YOUR_POD_NAME durch den Namen des Prefill-Leader-Pods oder des Decode-Leader-Pods aus der Ausgabe von kubectl get pods.

Bei einem Kaltstart dauert es etwa 4 bis 5 Minuten, die 2.400.000.000.000 NVFP4-Modellgewichtungen (~1,44 TB über 200 Shards) von Cloud Storage über Cloud Storage FUSE zu streamen und die SGLang-Server mit mehreren Hosts zu initialisieren. Warten Sie, bis die Frontend-Pods 1/1 und die Prefill- und Decode-Pods 2/2 in der Spalte READY von kubectl get pods anzeigen, bevor Sie Anfragen senden:
```
NAME                                                     READY   STATUS    RESTARTS   AGE
qwen3-8-2-4t-a4-disagg-0-decode-0-decode-ldr-wz92h       2/2     Running   0          5m
qwen3-8-2-4t-a4-disagg-0-decode-0-decode-wkr-fb8g6       2/2     Running   0          5m
qwen3-8-2-4t-a4-disagg-0-frontend-jrx4s                  1/1     Running   0          5m
qwen3-8-2-4t-a4-disagg-0-prefill-0-prefill-ldr-7nz25     2/2     Running   0          5m
qwen3-8-2-4t-a4-disagg-0-prefill-0-prefill-wkr-7d5cw     2/2     Running   0          5m
```

Inferenzanfragen senden

Senden Sie eine Anfrage zur Chat-Vervollständigung an den bereitgestellten Qwen3.8-2.4T-Dienst:

Leiten Sie den lokalen Port 8000 an den Dienst qwen3-8-2-4t-a4-disagg-frontend weiter:
```
kubectl port-forward svc/qwen3-8-2-4t-a4-disagg-frontend 8000:8000
```
Lassen Sie die Portweiterleitung in dieser Terminalsitzung laufen oder führen Sie den Befehl im Hintergrund aus.

Senden Sie in einer zweiten Terminalsitzung eine Anfrage zur Chat-Vervollständigung an den Endpunkt /v1/chat/completions:

curl -s http://127.0.0.1:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nvidia/Qwen3.8-2.4T-A95B-NVFP4",
    "messages": [{"role": "user", "content": "Explain KV-cache disaggregation in one sentence."}],
    "max_tokens": 64
  }' | jq .

Benchmark-Arbeitslast ausführen

Führen Sie einen Benchmark für den bereitgestellten Qwen3.8-2.4T-Server über den Dynamo-Frontend-Pod mit sglang.bench_serving und einer Konfiguration von 1.024 Eingabe-Tokens, 1.024 Ausgabe-Tokens (1k/1k), 256 Prompts und einer maximalen Nebenläufigkeit von 128 aus:

ROUTER_POD=$(kubectl get pod -l 'nvidia.com/dynamo-component-type=frontend' -o jsonpath='{.items[0].metadata.name}')

kubectl exec "${ROUTER_POD}" -- python3 -m sglang.bench_serving \
  --backend sglang-oai-chat \
  --base-url http://localhost:8000 \
  --model nvidia/Qwen3.8-2.4T-A95B-NVFP4 \
  --dataset-name random \
  --num-prompts 256 \
  --random-input-len 1024 \
  --random-output-len 1024 \
  --random-range-ratio 1.0 \
  --max-concurrency 128 | tee benchmark.log

Suchen Sie nach Abschluss des Benchmarks nach einer Ausgabe, die Messwerte wie die folgenden enthält:

Output token throughput
Total Token throughput
TTFT
TPOT

Bereinigen

So vermeiden Sie, dass Ihrem Google Cloud -Konto die in dieser Anleitung verwendeten Ressourcen laufend in Rechnung gestellt werden: Löschen Sie die Kubernetes-Arbeitslasten, den GKE-Cluster und den Cloud Storage-Bucket:

Löschen Sie die Ressourcen „DynamoGraphDeployment“ und „ResourceClaimTemplate“:

kubectl delete -f qwen3.8-2.4t-nvfp4-multihost-a4-gcsfuse.yaml --ignore-not-found || true

Deinstallieren Sie die NVIDIA Dynamo-Plattform und die KAI Scheduler Helm-Releases:
```
helm uninstall dynamo-platform kai-scheduler || true
```

Löschen Sie das Hugging Face-Kubernetes-Secret:

kubectl delete secret hf-secret --ignore-not-found || true

Löschen Sie im Verzeichnis cluster-toolkit den GKE-Cluster und die zugehörige Infrastruktur mit dem Befehl gcluster destroy:
```
cd cluster-toolkit
./gcluster destroy "${CLUSTER_NAME}" --auto-approve || true
cd ..
```
Löschen Sie den Cloud Storage-Bucket, in dem die bereitgestellten Modellgewichtungen und der Terraform-Status gespeichert sind:
```
gcloud storage rm --recursive "gs://${GCS_BUCKET}"
```