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

Qwen3-Coder-30B-A3B in der GKE mit Multi-Host-SGLang TorchTPU und PD-Disaggregation auf TPU v6e-Beschleunigern bereitstellen

In dieser Anleitung wird gezeigt, wie Sie Qwen3-Coder-30B-A3B (Qwen/Qwen3-Coder-30B-A3B-Instruct-FP8), ein Mixture of Experts-Codierungsmodell, in der Google Kubernetes Engine (GKE) bereitstellen und bereitstellen. Für die Bereitstellung werden Multi-Host-TPU v6e (Trillium)-Beschleuniger und das SGLang-Bereitstellungs-Framework mit TorchTPU (torchtpu) und Prefill-Decode-Disaggregation (PD) verwendet.

In der in dieser Anleitung beschriebenen Bereitstellungskonfiguration stellen Sie zwei ct6e-standard-4t-Knotenpools mit mehreren Hosts bereit, die jeweils in einer 2x4-Topologie angeordnet sind (acht TPU v6e-Chips auf zwei Knoten pro Knotenpool, also insgesamt 16 TPU v6e-Chips). Mit der Kubernetes LeaderWorkerSet API können Sie Folgendes tun:

Führen Sie disaggregierte Prefill- und Decodierungsserver mit mehreren Hosts auf separaten TPU v6e-Slices aus, wobei Tensor-Parallelität und Experten-Parallelität aktiviert sind.
Anfragen über einen SGLang-Disaggregationsrouter weiterleiten.

Wenn Sie einen ähnlichen SGLang TorchTPU-Bereitstellungsworkflow mit mehreren Hosts auf TPU7x-Beschleunigern (Ironwood) mit dem größeren Qwen3-Coder-480B-Modell ausführen möchten, lesen Sie den Hilfeartikel Qwen3-Coder-480B auf GKE mit SGLang TorchTPU mit mehreren Hosts und PD-Disaggregation auf TPU7x-Beschleunigern bereitstellen.

Ziele

Richten Sie Ihren GKE-Cluster und Ihre TPU v6e-Knotenpools mit mehreren Hosts ein.
Anmeldedaten konfigurieren und den LeaderWorkerSet-Controller installieren.
Stellen Sie die SGLang-Arbeitslasten für Prefill, Decode und Router auf mehreren Hosts bereit.
Senden Sie eine Inferenzanfrage an den SGLang-Routerdienst.
Führen Sie eine Benchmark-Arbeitslast für die Bereitstellung aus.
bereinigen.

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.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweis

Richten Sie die Umgebung für die Anleitung ein:

Installieren und initialisieren Sie die Google Cloud CLI und installieren Sie kubectl. Wenn Sie Cloud Shell verwenden, sind beide Tools vorinstalliert.
Aktivieren Sie die Kubernetes Engine API, die Compute Engine API, die Cloud TPU API und die Artifact Registry API in Ihrem Google Cloud -Projekt:

APIs aktivieren
Prüfen Sie, ob Ihr Projekt in der Region, in der sich Ihre TPU-Kapazität befindet, über ein ausreichendes Laufwerkskontingent und Kontingent für externe IP-Adressen verfügt:
1. Rufen Sie in der Google Cloud Console die Seite Kontingente und Systemlimits auf.
  
  Zur Seite „Kontingente und Systemlimits“
2. Prüfen Sie, ob Sie mindestens 400 GiB verfügbares Google Cloud Hyperdisk Balanced-Kontingent für die vier sitzungsspezifischen 100-GiB-Volumes haben, die von den Prefill- und Decode-Pods für das Modell-Caching verwendet werden.
3. Filtern Sie nach Genutzte regionale externe IPv4-Adressen und prüfen Sie, ob Sie in Ihrer Zielregion ein ausreichendes IP-Adresskontingent haben.

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)
Service Account User (roles/iam.serviceAccountUser)

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.

Achten Sie darauf, dass Ihr Compute Engine-Standarddienstkonto die folgenden IAM-Rollen (Identity and Access Management) für Ihr Projekt hat:

Kubernetes Engine Default Node Service Account (roles/container.defaultNodeServiceAccount)
Artifact Registry-Leser (roles/artifactregistry.reader)

Umgebungsvariablen einrichten

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

export CLUSTER_NAME="YOUR_CLUSTER_NAME"
export PROJECT_ID="YOUR_PROJECT_ID"
export REGION="YOUR_REGION"
export ZONE="YOUR_ZONE"
export RESERVATION="YOUR_RESERVATION_NAME"
export HF_TOKEN="YOUR_HF_TOKEN"
export SGLANG_IMAGE="lmsysorg/sglang:v0.1.0-tpu"

Ersetzen Sie Folgendes:

YOUR_CLUSTER_NAME: Name Ihres GKE-Clusters.
YOUR_PROJECT_ID: die ID Ihres Projekts in Google Cloud.
YOUR_REGION: die Region, in der Sie Ihren Cluster bereitstellen möchten, z. B. us-central1.
YOUR_ZONE: die Zone, in der Sie Ihre TPU v6e-Knotenpools bereitstellen möchten, z. B. us-central1-b.
YOUR_RESERVATION_NAME: Wenn Sie eine Reservierung verwenden, der Name Ihrer TPU v6e-Reservierung.
YOUR_HF_TOKEN: Ihr Hugging Face-Zugriffstoken.

Wenn Sie ein benutzerdefiniertes SGLang-TorchTPU-Container-Image verwenden, ersetzen Sie lmsysorg/sglang:v0.1.0-tpu in der Variablen SGLANG_IMAGE durch den URI Ihres Images.

GKE-Cluster erstellen

So erstellen Sie einen GKE-Cluster im Standardmodus und hängen zwei TPU v6e-Knotenpools mit mehreren Hosts für die Disaggregation von Vorbefüllung und Decodierung an:

Erstellen Sie einen regionalen GKE-Cluster, der e2-standard-4-Knoten für den Standardknotenpool verwendet. Dieser bietet ausreichend CPU- und Arbeitsspeicherressourcen für den LeaderWorkerSet-Controller und den SGLang-Disaggregationsrouter:
```
gcloud container clusters create "${CLUSTER_NAME}" \
  --project="${PROJECT_ID}" \
  --location="${REGION}" \
  --machine-type=e2-standard-4
```

Erstellen Sie zwei TPU v6e-Knotenpools mit mehreren Hosts, die jeweils zwei ct6e-standard-4t-Knoten enthalten (acht TPU v6e-Chips in einer 2x4-Topologie pro Knotenpool, insgesamt 16 TPU v6e-Chips):

gcloud container node-pools create tpu-v6e-pool-0 \
    --cluster="${CLUSTER_NAME}" \
    --location="${REGION}" \
    --node-locations="${ZONE}" \
    --machine-type=ct6e-standard-4t \
    --tpu-topology=2x4 \
    --num-nodes=2 \
    --reservation-affinity=specific \
    --reservation="${RESERVATION}" \
    --project="${PROJECT_ID}"

gcloud container node-pools create tpu-v6e-pool-1 \
    --cluster="${CLUSTER_NAME}" \
    --location="${REGION}" \
    --node-locations="${ZONE}" \
    --machine-type=ct6e-standard-4t \
    --tpu-topology=2x4 \
    --num-nodes=2 \
    --reservation-affinity=specific \
    --reservation="${RESERVATION}" \
    --project="${PROJECT_ID}"

Anstatt eine bestimmte Reservierung zu verwenden, können Sie die Knotenpools auch mit Spot-Kapazität oder Flex-Start-VMs erstellen:

Spot-VMs

Stellen Sie die Knotenpools mit Spot-Kapazität bereit, indem Sie die Flags --reservation-affinity=specific und --reservation="${RESERVATION}" durch das Flag --spot ersetzen:

gcloud container node-pools create tpu-v6e-pool-0 \
    --cluster="${CLUSTER_NAME}" \
    --location="${REGION}" \
    --node-locations="${ZONE}" \
    --machine-type=ct6e-standard-4t \
    --tpu-topology=2x4 \
    --num-nodes=2 \
    --project="${PROJECT_ID}" \
    --spot

gcloud container node-pools create tpu-v6e-pool-1 \
    --cluster="${CLUSTER_NAME}" \
    --location="${REGION}" \
    --node-locations="${ZONE}" \
    --machine-type=ct6e-standard-4t \
    --tpu-topology=2x4 \
    --num-nodes=2 \
    --project="${PROJECT_ID}" \
    --spot

Es kann einige Zeit dauern, bis Instanzen, die Spot-Kapazität verwenden, nach dem Erstellen des Knotenpools erstellt werden. Außerdem können sie während der Ausführung von Arbeitslasten vorzeitig beendet werden.

Flex-Start-VMs

Stellen Sie die Knotenpools mit der Verbrauchsoption Flex-Start bereit:

gcloud container node-pools create tpu-v6e-pool-0 \
    --cluster="${CLUSTER_NAME}" \
    --location="${REGION}" \
    --node-locations="${ZONE}" \
    --machine-type=ct6e-standard-4t \
    --tpu-topology=2x4 \
    --project="${PROJECT_ID}" \
    --reservation-affinity=none \
    --enable-autoscaling \
    --num-nodes=0 \
    --min-nodes=0 \
    --max-nodes=2 \
    --flex-start

gcloud container node-pools create tpu-v6e-pool-1 \
    --cluster="${CLUSTER_NAME}" \
    --location="${REGION}" \
    --node-locations="${ZONE}" \
    --machine-type=ct6e-standard-4t \
    --tpu-topology=2x4 \
    --project="${PROJECT_ID}" \
    --reservation-affinity=none \
    --enable-autoscaling \
    --num-nodes=0 \
    --min-nodes=0 \
    --max-nodes=2 \
    --flex-start

Weitere Informationen finden Sie unter Kleine Batcharbeitslast mit TPUs und Flex-Start-VMs ausführen.

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

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

Anmeldedaten konfigurieren und LeaderWorkerSet installieren

Führen Sie die folgenden Schritte aus, um Ihren Cluster für die SGLang-Bereitstellung auf mehreren Hosts vorzubereiten:

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}"
```

Installieren Sie die LeaderWorkerSet-CustomResourceDefinition und den Controller in Ihrem Cluster:

kubectl apply --server-side -k github.com/kubernetes-sigs/lws/config/default?ref=main
echo "Waiting for LWS controller to be ready..."
kubectl wait --for=condition=Available --timeout=300s deployment/lws-controller-manager -n lws-system

SGLang-Server mit mehreren Hosts bereitstellen

Im Arbeitslastmanifest (qwen3-coder-30b-multihost-disagg-v6e-2x4.yaml) werden die folgenden Ressourcen definiert, um die disaggregierte Bereitstellung von Prefill und Decodierung über die beiden 2x4-TPU-v6e-Knotenpools hinweg zu koordinieren:

StorageClass (hyperdisk-balanced-tpu): stellt sitzungsspezifische 100-GiB-ReadWriteOnce-Volumes bereit, die von Google Cloud Hyperdisk Balanced-Speicher unterstützt werden. Jeder der vier Pods für das Vorabfüllen und Decodieren stellt ein eigenes Volume unter /data bereit, um die heruntergeladenen Qwen/Qwen3-Coder-30B-A3B-Instruct-FP8-Prüfpunkte lokal zu speichern.
Prefill-Pool (sglang-prefill-service und sglang-tpu-prefill): Führt ein LeaderWorkerSet aus, das einen Leader-Pod und einen Worker-Pod enthält, die ausschließlich an einen 2x4-TPU-v6e-Knotenpool gebunden sind. Dieser Knotenpool hat acht TPU-Chips, die acht TensorCores bereitstellen. Das LeaderWorkerSet verwendet die Annotation leaderworkerset.sigs.k8s.io/exclusive-topology, die auf "cloud.google.com/gke-nodepool" festgelegt ist. Die Pods starten sglang.launch_server mit den folgenden Flags und stellen Port 8000 und Bootstrap-Port 8998 bereit:
- --disaggregation-mode=prefill
- --tensor-parallel-size=8
- --ep-size=8
Decodierungspool (sglang-decode-service und sglang-tpu-decode): Führt ein LeaderWorkerSet von size: 2 aus, das an den zweiten 2x4-TPU-v6e-Knotenpool (acht TPU-Chips, die acht TensorCores bereitstellen) angehängt ist. Das LeaderWorkerSet startet sglang.launch_server mit den folgenden Flags:
- --disaggregation-mode=decode
- --tensor-parallel-size=8
- --ep-size=8
Disaggregationsrouter (sglang-router und sglang-service): Führt ein CPU-Deployment aus, das das sglang_router.launch_router-Modul mit dem Flag --pd-disaggregation ausführt und einen ClusterIP-Dienst auf Port 8000 bereitstellt. Der Router leitet Prompts weiter und koordiniert die KV-Cache-Übertragung zwischen den Diensten sglang-prefill-service und sglang-decode-service.

So stellen Sie die SGLang-Server mit mehreren Hosts bereit und überwachen sie:

Laden Sie das Arbeitslastmanifest herunter:

curl -LO https://raw.githubusercontent.com/GoogleCloudSamples/AIHypercomputerSamples/main/tpu/inference/qwen3-coder/qwen3-coder-30b-multihost-disagg-v6e-2x4.yaml

Alternativ können Sie eine Datei mit dem Namen qwen3-coder-30b-multihost-disagg-v6e-2x4.yaml und folgendem Inhalt erstellen:

# ==============================================================================
# Serve Qwen/Qwen3-Coder-30B-A3B-Instruct-FP8 on GKE / Trillium (TPU v6e)
# using SGLang TorchTPU with Prefill/Decode Disaggregation, multi-host (2x4)
# ==============================================================================
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: hyperdisk-balanced-tpu
provisioner: pd.csi.storage.gke.io
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true
parameters:
  type: hyperdisk-balanced
---
# ==============================================================================
# PREFILL POOL: Internal ClusterIP Service exposing SGLang Prefill Endpoint
# ==============================================================================
apiVersion: v1
kind: Service
metadata:
  name: sglang-prefill-service
  labels:
    app: sglang-prefill
spec:
  type: ClusterIP
  selector:
    app: sglang-prefill
    role: leader
  ports:
    - name: http
      protocol: TCP
      port: 8000
      targetPort: 8000
    - name: bootstrap
      protocol: TCP
      port: 8998
      targetPort: 8998
---
# ==============================================================================
# PREFILL POOL: LeaderWorkerSet (TPU v6e, 1 slice = 2 nodes, 8 chips / 8 TensorCores, 2x4)
# ==============================================================================
apiVersion: leaderworkerset.x-k8s.io/v1
kind: LeaderWorkerSet
metadata:
  name: sglang-tpu-prefill
  annotations:
    leaderworkerset.sigs.k8s.io/exclusive-topology: "cloud.google.com/gke-nodepool"
  labels:
    app: sglang-prefill
spec:
  replicas: 1
  rolloutStrategy:
    type: RollingUpdate
  leaderWorkerTemplate:
    size: 2
    restartPolicy: RecreateGroupOnPodRestart
    leaderTemplate:
      metadata:
        labels:
          app: sglang-prefill
          role: leader
      spec: &prefill-pod-spec
        securityContext:
          fsGroup: 65534
        nodeSelector:
          cloud.google.com/gke-tpu-accelerator: tpu-v6e-slice
          cloud.google.com/gke-tpu-topology: 2x4
        tolerations:
          - key: "google.com/tpu"
            operator: "Exists"
            effect: "NoSchedule"
        containers:
          - name: sglang
            image: $SGLANG_IMAGE
            command:
              - /bin/bash
              - -c
              - |
                set -ex
                ulimit -c 0
                LEADER_POD="${LWS_LEADER_ADDRESS%%.*}"
                DNS_SUFFIX="${LWS_LEADER_ADDRESS#*.}"
                HOSTS="${LWS_LEADER_ADDRESS}"
                for ((i = 1; i < LWS_GROUP_SIZE; i++)); do
                  HOSTS="${HOSTS},${LEADER_POD}-${i}.${DNS_SUFFIX}"
                done
                export TPU_WORKER_HOSTNAMES="${HOSTS}"
                export TPU_WORKER_ID="${LWS_WORKER_INDEX}"
                export TORCH_TPU_DEVICES_PER_HOST=4
                export TPU_TOPOLOGY="2x4x1"
                echo "=== [prefill rank ${LWS_WORKER_INDEX}/${LWS_GROUP_SIZE}] hosts=${TPU_WORKER_HOSTNAMES} ==="
                exec python3 -m sglang.launch_server \
                  --device=tpu \
                  --host=0.0.0.0 \
                  --port=8000 \
                  --model-path=Qwen/Qwen3-Coder-30B-A3B-Instruct-FP8 \
                  --tensor-parallel-size=8 \
                  --ep-size=8 \
                  --nnodes="${LWS_GROUP_SIZE}" \
                  --node-rank="${LWS_WORKER_INDEX}" \
                  --dist-init-addr="${LWS_LEADER_ADDRESS}:20000" \
                  --attention-backend=pallas_tpu_rpa_batched \
                  --mem-fraction-static=0.8 \
                  --max-running-requests=256 \
                  --chunked-prefill-size=8192 \
                  --max-total-tokens=524288 \
                  --context-length=9216 \
                  --enable-torch-compile \
                  --torch-compile-max-bs=256 \
                  --tpu-compile-tracer=direct \
                  --sampling-defaults=openai \
                  --enable-fused-qk-norm-rope \
                  --disaggregation-mode=prefill \
                  --disaggregation-transfer-backend=tpu \
                  --download-dir=/data \
                  --tpu-compile-tokens=8192 \
                  --disable-radix-cache
            env:
              - name: HF_TOKEN
                valueFrom:
                  secretKeyRef:
                    name: hf-secret
                    key: hf_api_token
                    optional: true
            resources:
              requests:
                cpu: "16"
                memory: 128Gi
                google.com/tpu: "4"
              limits:
                memory: 280Gi
                google.com/tpu: "4"
            ports:
              - containerPort: 8000
                name: http
              - containerPort: 8998
                name: bootstrap
            startupProbe:
              httpGet:
                path: /health
                port: 8000
              initialDelaySeconds: 60
              periodSeconds: 15
              timeoutSeconds: 10
              failureThreshold: 236
            readinessProbe:
              httpGet:
                path: /health
                port: 8000
              periodSeconds: 10
              timeoutSeconds: 5
              failureThreshold: 3
            volumeMounts:
              - name: model-cache
                mountPath: /data
              - name: dshm
                mountPath: /dev/shm
        volumes:
          - name: dshm
            emptyDir:
              medium: Memory
              sizeLimit: 32Gi
          - name: model-cache
            ephemeral:
              volumeClaimTemplate:
                spec:
                  accessModes: ["ReadWriteOnce"]
                  storageClassName: hyperdisk-balanced-tpu
                  resources:
                    requests:
                      storage: 100Gi
    workerTemplate:
      metadata:
        labels:
          app: sglang-prefill
          role: worker
      spec: *prefill-pod-spec
---
# ==============================================================================
# DECODE POOL: Internal ClusterIP Service exposing SGLang Decode Endpoint
# ==============================================================================
apiVersion: v1
kind: Service
metadata:
  name: sglang-decode-service
  labels:
    app: sglang-decode
spec:
  type: ClusterIP
  selector:
    app: sglang-decode
    role: leader
  ports:
    - name: http
      protocol: TCP
      port: 8000
      targetPort: 8000
    - name: bootstrap
      protocol: TCP
      port: 8998
      targetPort: 8998
---
# ==============================================================================
# DECODE POOL: LeaderWorkerSet (TPU v6e, 1 slice = 2 nodes, 8 chips / 8 TensorCores, 2x4)
# ==============================================================================
apiVersion: leaderworkerset.x-k8s.io/v1
kind: LeaderWorkerSet
metadata:
  name: sglang-tpu-decode
  annotations:
    leaderworkerset.sigs.k8s.io/exclusive-topology: "cloud.google.com/gke-nodepool"
  labels:
    app: sglang-decode
spec:
  replicas: 1
  rolloutStrategy:
    type: RollingUpdate
  leaderWorkerTemplate:
    size: 2
    restartPolicy: RecreateGroupOnPodRestart
    leaderTemplate:
      metadata:
        labels:
          app: sglang-decode
          role: leader
      spec: &decode-pod-spec
        securityContext:
          fsGroup: 65534
        nodeSelector:
          cloud.google.com/gke-tpu-accelerator: tpu-v6e-slice
          cloud.google.com/gke-tpu-topology: 2x4
        tolerations:
          - key: "google.com/tpu"
            operator: "Exists"
            effect: "NoSchedule"
        containers:
          - name: sglang
            image: $SGLANG_IMAGE
            command:
              - /bin/bash
              - -c
              - |
                set -ex
                ulimit -c 0
                LEADER_POD="${LWS_LEADER_ADDRESS%%.*}"
                DNS_SUFFIX="${LWS_LEADER_ADDRESS#*.}"
                HOSTS="${LWS_LEADER_ADDRESS}"
                for ((i = 1; i < LWS_GROUP_SIZE; i++)); do
                  HOSTS="${HOSTS},${LEADER_POD}-${i}.${DNS_SUFFIX}"
                done
                export TPU_WORKER_HOSTNAMES="${HOSTS}"
                export TPU_WORKER_ID="${LWS_WORKER_INDEX}"
                export TORCH_TPU_DEVICES_PER_HOST=4
                export TPU_TOPOLOGY="2x4x1"
                echo "=== [decode rank ${LWS_WORKER_INDEX}/${LWS_GROUP_SIZE}] hosts=${TPU_WORKER_HOSTNAMES} ==="
                exec python3 -m sglang.launch_server \
                  --device=tpu \
                  --host=0.0.0.0 \
                  --port=8000 \
                  --model-path=Qwen/Qwen3-Coder-30B-A3B-Instruct-FP8 \
                  --tensor-parallel-size=8 \
                  --ep-size=8 \
                  --nnodes="${LWS_GROUP_SIZE}" \
                  --node-rank="${LWS_WORKER_INDEX}" \
                  --dist-init-addr="${LWS_LEADER_ADDRESS}:20000" \
                  --attention-backend=pallas_tpu_rpa_batched \
                  --mem-fraction-static=0.8 \
                  --max-running-requests=256 \
                  --chunked-prefill-size=8192 \
                  --max-total-tokens=524288 \
                  --context-length=9216 \
                  --enable-torch-compile \
                  --torch-compile-max-bs=256 \
                  --tpu-compile-tracer=direct \
                  --sampling-defaults=openai \
                  --enable-fused-qk-norm-rope \
                  --disaggregation-mode=decode \
                  --disaggregation-transfer-backend=tpu \
                  --download-dir=/data
            env:
              - name: HF_TOKEN
                valueFrom:
                  secretKeyRef:
                    name: hf-secret
                    key: hf_api_token
                    optional: true
            resources:
              requests:
                cpu: "16"
                memory: 128Gi
                google.com/tpu: "4"
              limits:
                memory: 280Gi
                google.com/tpu: "4"
            ports:
              - containerPort: 8000
                name: http
              - containerPort: 8998
                name: bootstrap
            startupProbe:
              httpGet:
                path: /health
                port: 8000
              initialDelaySeconds: 60
              periodSeconds: 15
              timeoutSeconds: 10
              failureThreshold: 236
            readinessProbe:
              httpGet:
                path: /health
                port: 8000
              periodSeconds: 10
              timeoutSeconds: 5
              failureThreshold: 3
            volumeMounts:
              - name: model-cache
                mountPath: /data
              - name: dshm
                mountPath: /dev/shm
        volumes:
          - name: dshm
            emptyDir:
              medium: Memory
              sizeLimit: 32Gi
          - name: model-cache
            ephemeral:
              volumeClaimTemplate:
                spec:
                  accessModes: ["ReadWriteOnce"]
                  storageClassName: hyperdisk-balanced-tpu
                  resources:
                    requests:
                      storage: 100Gi
    workerTemplate:
      metadata:
        labels:
          app: sglang-decode
          role: worker
      spec: *decode-pod-spec
---
# ==============================================================================
# SGLANG DISAGGREGATION ROUTER / PROXY DEPLOYMENT
# ==============================================================================
apiVersion: apps/v1
kind: Deployment
metadata:
  name: sglang-router
  labels:
    app: sglang-router
spec:
  replicas: 1
  selector:
    matchLabels:
      app: sglang-router
  template:
    metadata:
      labels:
        app: sglang-router
    spec:
      containers:
        - name: router
          image: $SGLANG_IMAGE
          command:
            - python3
            - -m
            - sglang_router.launch_router
          args:
            - --pd-disaggregation
            - --prefill
            - http://sglang-prefill-service:8000
            - "8998"
            - --decode
            - http://sglang-decode-service:8000
            - --host
            - 0.0.0.0
            - --port
            - "8000"
            - --model-path
            - Qwen/Qwen3-Coder-30B-A3B-Instruct-FP8
            - --request-timeout-secs
            - "3600"
            - --worker-startup-timeout-secs
            - "5400"
          env:
            - name: HF_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-secret
                  key: hf_api_token
                  optional: true
          ports:
            - containerPort: 8000
              name: http
          readinessProbe:
            httpGet:
              path: /health_generate
              port: 8000
            initialDelaySeconds: 15
            periodSeconds: 30
            timeoutSeconds: 10
            failureThreshold: 3
          resources:
            requests:
              cpu: "1"
              memory: 4Gi
            limits:
              cpu: "4"
              memory: 12Gi
---
# ==============================================================================
# SGLANG EXTERNAL SERVICE: Public / Client Endpoint for OpenAI-compatible Serving
# ==============================================================================
apiVersion: v1
kind: Service
metadata:
  name: sglang-service
  labels:
    app: sglang-router
spec:
  type: ClusterIP
  selector:
    app: sglang-router
  ports:
    - name: http
      protocol: TCP
      port: 8000
      targetPort: 8000

Wenden Sie das Arbeitslastmanifest auf Ihren Cluster an:

envsubst '$SGLANG_IMAGE' < qwen3-coder-30b-multihost-disagg-v6e-2x4.yaml | kubectl apply -f -

Prüfen Sie, ob die Router-, Prefill- und Decodierungs-Pods erstellt wurden:

kubectl get pods

Wenn alle Pods bereit sind, sieht die Ausgabe in etwa so aus:

NAME                             READY   STATUS    RESTARTS   AGE
sglang-router-6d87cb8c7d-gv4wr   1/1     Running   0          39m
sglang-tpu-decode-0              1/1     Running   0          40m
sglang-tpu-decode-0-1            1/1     Running   0          40m
sglang-tpu-prefill-0             1/1     Running   0          40m
sglang-tpu-prefill-0-1           1/1     Running   0          40m

Beobachten Sie die Logs des Prefill- und Decode-Leader-Pods, bis der Start abgeschlossen ist:
```
kubectl logs -f -l role=leader --prefix=true &
LOG_PID=$!
kubectl wait --for=condition=Ready --timeout=3600s pod -l role=leader
kill "${LOG_PID}" 2>/dev/null || true
```
Der erste Download des Modells, das Laden der Gewichtungen und die Kompilierung dauern beim ersten Durchlauf etwa sieben bis zehn Minuten.

Wenn Sie Kapazität auf Abruf wie Spot-Kapazität oder Flex-Start-VMs verwenden, kann es nach dem Erstellen des Knotenpools länger dauern, bis Ihre TPU-Slice-Knoten erstellt werden. Außerdem können sie während der Ausführung von Arbeitslasten vorzeitig beendet werden. Weitere Informationen finden Sie unter VM-Instanzen auf Abruf. Informationen zum Prüfen, ob Ihre TPU-Slice-Knoten erstellt wurden, finden Sie unter Status und Bedingungen des Knotens prüfen.

Warten Sie, bis in den Logs der Leader-Pods für Vorbefüllung und Decodierung die folgende Meldung ausgegeben wird und kubectl get pods für alle Pods 1/1 in der Spalte READY anzeigt:
```
The server is fired up and ready to roll!
```
Öffnen Sie eine zweite Terminalsitzung und leiten Sie den lokalen Port 8000 an sglang-service weiter:
```
kubectl port-forward service/sglang-service 8000:8000
```
Lassen Sie die Portweiterleitung in dieser Terminalsitzung laufen.

Inferenzanfragen senden

Kehren Sie zur ersten Terminalsitzung zurück und senden Sie eine Anfrage zur Chatvervollständigung an den /v1/chat/completions-Endpunkt, der vom SGLang-Router bereitgestellt wird:








  
  














  
  
  
  





  
    
  
  











  









  




  



  curl -s -X POST http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen3-Coder-30B-A3B-Instruct-FP8",
    "messages": [
      {"role": "user", "content": "Explain quicksort in two sentences."}
    ],
    "max_tokens": 60,
    "temperature": 0.0
  }'





























Benchmark-Arbeitslast ausführen

Führen Sie den folgenden Befehl aus, um das bereitgestellte Qwen3-Coder-30B-A3B-Modell mit einer Arbeitslast von 1.024 Token Eingabe und 1.024 Token Ausgabe (1k/1k) vom sglang-router-Pod zu benchmarken:








  
  














  
  
  
  





  
    
  
  











  









  




  



  
kubectl exec deployment/sglang-router -- python3 -m sglang.bench_serving \
  --backend sglang \
  --base-url http://localhost:8000 \
  --model Qwen/Qwen3-Coder-30B-A3B-Instruct-FP8 \
  --dataset-name random \
  --random-input-len 1024 \
  --random-output-len 1024 \
  --random-range-ratio 1.0 \
  --num-prompts 256 \
  --max-concurrency 256





























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
      
      

Wenn Sie vermeiden möchten, dass Ihrem Google Cloud Konto die in dieser Anleitung verwendeten Ressourcen weiterhin in Rechnung gestellt werden, löschen Sie die folgenden Ressourcen:


Löschen Sie die SGLang-Arbeitslasten für Vorbefüllung, Decodierung und Router:








  
  














  
  
  
  





  
    
  
  











  









  




  



  
kubectl delete -f qwen3-coder-30b-multihost-disagg-v6e-2x4.yaml --ignore-not-found




























Löschen Sie die TPU v6e-Knotenpools und den GKE-Cluster:








  
  














  
  
  
  





  
    
  
  











  









  




  



  
gcloud container node-pools delete tpu-v6e-pool-0 \
    --cluster="${CLUSTER_NAME}" \
    --location="${REGION}" \
    --project="${PROJECT_ID}" \
    --quiet

gcloud container node-pools delete tpu-v6e-pool-1 \
    --cluster="${CLUSTER_NAME}" \
    --location="${REGION}" \
    --project="${PROJECT_ID}" \
    --quiet

gcloud container clusters delete "${CLUSTER_NAME}" \
    --location="${REGION}" \
    --project="${PROJECT_ID}" \
    --quiet































    
    

    
    
      Nächste Schritte
      


SGLang
Weitere Informationen zu TPU v6e (Trillium)
Weitere Informationen zu Cloud TPU

Qwen3-Coder-30B-A3B in der GKE mit Multi-Host-SGLang TorchTPU und PD-Disaggregation auf TPU v6e-Beschleunigern bereitstellen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.