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

Verstärkungslernen mit verl in GKE abstimmen und skalieren

Autopilot Standard

In dieser Anleitung wird gezeigt, wie Sie eine verteilte Trainingsumgebung für Reinforcement Learning in Google Kubernetes Engine (GKE) orchestrieren. Sie verwenden Ray und das Framework verl (Volcano Engine Reinforcement Learning), um eine Umgebung für verteiltes Training einzurichten, in der Sie ein Qwen2.5-32B-Instruct-Modell für das GSM8K-Dataset abstimmen.

In dieser Anleitung geht es um die Trainingspipeline für die Group Relative Policy Optimization (GRPO) in GKE mit Ray und verl. GRPO ist ein Reinforcement-Learning-Algorithmus, der die Fähigkeit eines Modells zum logischen Denken verbessern soll. Dieser speichereffiziente Algorithmus vereinfacht den Prozess des bestärkenden Lernens (Reinforcement Learning, RL), indem er den Critic oder das Wertmodell eliminiert und stattdessen eine relative gruppenbasierte Berechnung verwendet.

Dieses Tutorial ist ein guter Ausgangspunkt, wenn Sie eine Umgebung für verteiltes Training einrichten müssen, in der Daten, Modellgewichte und die Trainings-Engine zur Steigerung der Effizienz entkoppelt sind.

Diese Anleitung unterstützt die folgenden GPU-Architekturen:

GPU-Knoten auf Intel- oder AMD-Basis: Richten Sie die Skalierung mit NVIDIA B200- oder H200-GPUs ein und verwenden Sie die dynamische Ressourcenzuweisung (Dynamic Resource Allocation, DRA) von GKE für den Autopilot-Pfad.
Arm-basierte A4X-Knoten (GB200): Einrichten und skalieren mit NVIDIA GB200 Grace Blackwell-Superchips mit GKE Dynamic Resource Allocation (DRA) und Multi-Node NVLink (IMEX).

Hintergrund

In den folgenden Abschnitten erhalten Sie einen kurzen Überblick über die in diesem Tutorial verwendeten Konzepte.

Bestärkendes Lernen (Reinforcement Learning, RL)

Beim bestärkenden Lernen werden Modelle durch Erfahrung, Erkundung und Feedback trainiert, anstatt durch statische Imitation. Durch das Vortraining lernt ein Modell, was es sagen soll. Durch bestärkendes Lernen durch menschliches Feedback (Reinforcement Learning from Human Feedback, RLHF) lernt es, wie es hilfreich, sicher und logisch sein kann. RL dient als Brücke zwischen einem Basismodell und einem feinabgestimmten Modell für einen speziellen Anwendungsfall.

Weitere Informationen finden Sie unter Was ist bestärkendes Lernen?

Gruppenrelative Richtlinienoptimierung (Group Relative Policy Optimization, GRPO)

GRPO, ein von DeepSeek entwickelter Algorithmus, bietet eine speichereffiziente Alternative zur Proximal Policy Optimization (PPO) für die LLM-Abstimmung, da das Critic-Modell entfernt wird. Anstelle eines Critic-Netzwerks generiert GRPO eine Gruppe von Antworten für denselben Prompt und verwendet die durchschnittliche Belohnung dieser Gruppe als Baseline.

Weitere Informationen finden Sie unter GRPO.

Volcano Engine Reinforcement Learning (VERL)

verl ist ein leistungsstarkes Framework, das für die komplexen Speicher- und Rechenmuster von LLM-basiertem RL entwickelt wurde.

Weitere Informationen finden Sie unter verl.

Ziele

In dieser Anleitung erfahren Sie, wie Sie mit verl Reinforcement Learning in GKE einrichten. Dazu führen Sie die folgenden Schritte aus:

Richten Sie einen GKE-Cluster mit A4X-Superchips (GB200), A4-GPUs (B200) oder A3 Ultra-GPUs (H200) ein.
KubeRay zum Verwalten eines verteilten Ray-Clusters konfigurieren
Stellen Sie einen Cloud Storage-Bucket mit Cloud Storage FUSE auf allen Knoten bereit.
Führen Sie einen GRPO-Trainingsjob mit verl aus, um das Modell Qwen2.5-32B-Instruct mit dem GSM8K-Dataset abzustimmen.

Hinweis

Melden Sie sich in Ihrem Google Cloud -Konto an. Wenn Sie mit Google Cloudnoch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Installieren Sie die Google Cloud CLI.

Hinweis:Wenn Sie die gcloud CLI zuvor installiert haben, prüfen Sie, ob Sie die aktuelle Version haben, indem Sie gcloud components update ausführen.

Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren:

gcloud init

Erstellen Sie ein Google Cloud Projekt oder wählen Sie eines aus.

Rollen, die zum Auswählen oder Erstellen eines Projekts erforderlich sind

Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können jedes Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Projektersteller“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Weitere Informationen zum Zuweisen von Rollen

So erstellen Sie ein Google Cloud Projekt:
```
gcloud projects create PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch einen Namen für das Google Cloud Projekt, das Sie erstellen.
Wählen Sie das von Ihnen erstellte Google Cloud Projekt aus:
```
gcloud config set project PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch den Namen Ihres Projekts in Google Cloud .

Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Projekt aktiviert ist.

Aktivieren Sie die erforderlichen APIs:

Rollen, die zum Aktivieren von APIs erforderlich sind

Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Rolle „Inhaber“ (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. Informationen zum Zuweisen von Rollen

gcloud services enable container.googleapis.com storage.googleapis.com compute.googleapis.com

Installieren Sie die Google Cloud CLI.

Hinweis:Wenn Sie die gcloud CLI zuvor installiert haben, prüfen Sie, ob Sie die aktuelle Version haben, indem Sie gcloud components update ausführen.

Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren:

gcloud init

Erstellen Sie ein Google Cloud Projekt oder wählen Sie eines aus.

Rollen, die zum Auswählen oder Erstellen eines Projekts erforderlich sind

Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können jedes Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Projektersteller“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Weitere Informationen zum Zuweisen von Rollen

So erstellen Sie ein Google Cloud Projekt:
```
gcloud projects create PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch einen Namen für das Google Cloud Projekt, das Sie erstellen.
Wählen Sie das von Ihnen erstellte Google Cloud Projekt aus:
```
gcloud config set project PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch den Namen Ihres Projekts in Google Cloud .

Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Projekt aktiviert ist.

Aktivieren Sie die erforderlichen APIs:

Rollen, die zum Aktivieren von APIs erforderlich sind

gcloud services enable container.googleapis.com storage.googleapis.com compute.googleapis.com

Weisen Sie Ihrem Nutzerkonto Rollen zu. Führen Sie den folgenden Befehl für jede der folgenden IAM-Rollen einmal aus: roles/container.admin, roles/iam.serviceAccountAdmin, roles/storage.admin
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
Ersetzen Sie Folgendes:
- PROJECT_ID: Ihre Projekt-ID.
- USER_IDENTIFIER: Die Kennung für Ihr Nutzerkonto . Beispiel: myemail@example.com
- ROLE: Die IAM-Rolle, die Sie Ihrem Nutzerkonto zuweisen.

Erstellen Sie ein Hugging Face-Konto, falls Sie noch keines haben.
Sie benötigen ein Hugging Face-Token.
Prüfen Sie, ob Ihr Projekt ein ausreichendes Kontingent für A4X-Superchips (GB200), A4-GPUs (B200) oder A3 Ultra-GPUs (H200) hat. Weitere Informationen finden Sie unter GPU-Kontingent planen und GPU-Kontingent.
Achten Sie darauf, dass Sie eine aktive Kapazitätsreservierung für Ihren GPU-Maschinentyp haben. Weitere Informationen finden Sie unter Kapazität über Ihr Account-Management-Team reservieren.
Für die Einrichtung von A4X (GB200) muss Helm installiert sein.

Umgebung vorbereiten

In dieser Anleitung verwenden Sie Cloud Shell.

Rufen Sie die Google Cloud Console auf.
Klicken Sie oben im Google Cloud Console-Fenster auf den Button Cloud Shell aktivieren.

Legen Sie die Umgebungsvariablen fest:

A4 und A3 Ultra

Autopilot

export PROJECT_ID=$(gcloud config get project)
export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")
export CONTROL_PLANE_REGION="YOUR_REGION"
export NODE_ZONE="YOUR_ZONE"
export CLUSTER_NAME="YOUR_CLUSTER_NAME"
export KSA_NAME="YOUR_KSA_NAME"
export GS_BUCKET="YOUR_GCS_BUCKET"
export NAMESPACE="default"
export GPU_TYPE="YOUR_GPU_TYPE"
export MACHINE_TYPE="YOUR_MACHINE_TYPE"
export RESERVATION="YOUR_RESERVATION_NAME"
export HF_TOKEN="YOUR_HF_TOKEN"

Standard

export PROJECT_ID=$(gcloud config get project)
export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")
export CONTROL_PLANE_REGION="YOUR_REGION"
export NODE_ZONE="YOUR_ZONE"
export CLUSTER_NAME="YOUR_CLUSTER_NAME"
export KSA_NAME="YOUR_KSA_NAME"
export GS_BUCKET="YOUR_GCS_BUCKET"
export NAMESPACE="default"
export GPU_TYPE="YOUR_GPU_TYPE"
export MACHINE_TYPE="YOUR_MACHINE_TYPE"
export RESERVATION="YOUR_RESERVATION_NAME"
export HF_TOKEN="YOUR_HF_TOKEN"

export GVNIC_NETWORK_PREFIX="GVNIC_NAME"
export RDMA_NETWORK_PREFIX="RDMA_NAME"

A4X

export PROJECT_ID=$(gcloud config get project)
export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")
export CONTROL_PLANE_REGION=YOUR_REGION
export NODE_ZONE=YOUR_ZONE
export CLUSTER_NAME=YOUR_CLUSTER_NAME
export KSA_NAME=YOUR_KSA_NAME
export GS_BUCKET=YOUR_GCS_BUCKET-${PROJECT_ID}
export NAMESPACE=default
export GPU_TYPE=YOUR_GPU_TYPE
export MACHINE_TYPE=YOUR_MACINE_TYPE
export RESERVATION=YOUR_RESERVATION_NAME
export HF_TOKEN=YOUR_HF_TOKEN

# A4X (GB200 Superchips) only variables
export NUM_GPU_NODES=4
export VERL_IMAGE=verlai/verl:vllm023.aarch64.dev1
export VERL_REF=ddbcdb7

Ersetzen Sie die folgenden Werte:

YOUR_REGION: die Compute Engine-Region für die GKE-Cluster-Steuerungsebene.
YOUR_ZONE: die Zone, in der die Knoten reserviert sind. Weitere Informationen finden Sie unter GPU-Verfügbarkeit.
YOUR_CLUSTER_NAME: Name Ihres GKE-Clusters.
YOUR_KSA_NAME: Der Name Ihres Kubernetes-Dienstkontos.
YOUR_GCS_BUCKET: Der Basisname für Ihren Cloud Storage-Bucket. Sie müssen das Präfix gs:// nicht angeben.
YOUR_GPU_TYPE: der Beschleuniger, den Sie in der Compute Engine-Kapazitätsreservierung reserviert haben. Es muss einer der folgenden Werte sein:
- nvidia-gb200: A4X (GB200 Superchips)
- nvidia-b200: A4 (B200-GPUs)
- nvidia-h200-141gb: A3 Ultra (H200-GPUs)
YOUR_MACHINE_TYPE: der zu verwendende Maschinentyp:
- Verwenden Sie für A4X-Superchips (GB200) a4x-highgpu-4g.
- Verwenden Sie für A4-GPUs (B200) a4-highgpu-8g oder höher.
- Für A3 Ultra (H200-GPUs) verwenden Sie a3-ultragpu-8g oder höher.
YOUR_RESERVATION_NAME: Der Name Ihrer Kapazitätsreservierung.
YOUR_HF_TOKEN: Ihr Hugging Face-Token.
Nur Google Kubernetes Engine (GKE) Standard Edition:
- GVNIC_NAME (nur GKE Standard – A4 oder A3 Ultra): Das Präfix für den gVNIC-Netzwerknamen. Sie können ein beliebiges Präfix verwenden.
- RDMA_NAME (nur A4 oder A3 Ultra): Das Präfix für das RDMA-Netzwerk (Remote Direct Memory Access). Sie können ein beliebiges Präfix verwenden.

Klonen Sie das Beispiel-Repository:

git clone https://github.com/GoogleCloudSamples/AIHypercomputerSamples.git

Wechseln Sie zum Arbeitsverzeichnis für den ausgewählten GKE-Modus:
A4 und A3 Ultra
Autopilot

cd AIHypercomputerSamples/gpu/tuning/verl_rl_autopilot

Standard

cd AIHypercomputerSamples/gpu/tuning/verl_rl_standard
A4X
Es ist keine Änderung des Verzeichnisses erforderlich. Sie können direkt mit dem nächsten Abschnitt fortfahren.

Infrastruktur einrichten

In diesem Abschnitt erstellen Sie Standard-VPC-Netzwerke und den GKE-Cluster.

RDMA-Netzwerk und ‑Subnetze erstellen (nur GKE Standard – A4 und A3 Ultra)

A4 und A3 Ultra

Autopilot

Dieser Abschnitt ist nur für GKE Standard A4- und A3 Ultra-GPUs erforderlich.

Wenn Sie Autopilot verwenden, überspringen Sie diesen Abschnitt und fahren Sie direkt mit GKE-Cluster erstellen fort. GKE stellt automatisch die erforderlichen VPC-Netzwerke und Subnetze bereit und verwendet GKE-verwaltetes DRANET, um diese Ressourcen Ihren Pods zuzuweisen. Sie müssen keine Netzwerkinfrastruktur manuell erstellen.

Standard

VPC-Netzwerk für die gVNIC-Schnittstelle erstellen:

gcloud compute networks create ${GVNIC_NETWORK_PREFIX}-net \
  --subnet-mode=custom \
  --project=${PROJECT_ID}

gcloud compute networks subnets create ${GVNIC_NETWORK_PREFIX}-sub \
  --network=${GVNIC_NETWORK_PREFIX}-net \
  --region=${CONTROL_PLANE_REGION} \
  --range=192.168.0.0/24 \
  --project=${PROJECT_ID}

gcloud compute firewall-rules create ${GVNIC_NETWORK_PREFIX}-internal \
  --network=${GVNIC_NETWORK_PREFIX}-net \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=192.168.0.0/16 \
  --project=${PROJECT_ID}

VPC-Netzwerk für RDMA erstellen:

gcloud beta compute networks create ${RDMA_NETWORK_PREFIX}-net \
  --network-profile=${NODE_ZONE}-vpc-roce \
  --subnet-mode=custom \
  --project=${PROJECT_ID}

Erstellen Sie die 8 RDMA-Subnetze für die 8 GPUs:

for N in $(seq 0 7); do
  if ! gcloud compute networks subnets describe ${RDMA_NETWORK_PREFIX}-sub-$N --region=${CONTROL_PLANE_REGION} --project=${PROJECT_ID} >/dev/null 2>&1; then
    gcloud compute networks subnets create ${RDMA_NETWORK_PREFIX}-sub-$N \
      --network=${RDMA_NETWORK_PREFIX}-net \
      --region=${CONTROL_PLANE_REGION} \
      --range=192.168.$((N+1)).0/24 \
      --project=${PROJECT_ID} &
  else
    echo "Subnet ${RDMA_NETWORK_PREFIX}-sub-$N already exists."
  fi
done
wait

A4X

Dieser Abschnitt ist nur für GKE Standard A4- und A3 Ultra-GPUs erforderlich.

Wenn Sie A4X-GPUs (GB200) verwenden, überspringen Sie diesen Abschnitt und fahren Sie direkt mit GKE-Cluster erstellen fort. Bei A4X-GPUs (GB200) oder Autopilot erstellt GKE die Netzwerke automatisch, wenn für den Knotenpool das auto-Beschleunigernetzwerkprofil verwendet wird. Im Cluster Toolkit-Blueprint wird dieses Profil mit dem Flag enable_dranet:true aktiviert.

GKE-Cluster erstellen

Erstellen Sie einen GKE-Cluster, der Ihrer GPU-Architektur entspricht:

A4 und A3 Ultra

Wählen Sie den gewünschten GKE-Clustermodus aus:

Autopilot

Autopilot-Cluster erstellen:

gcloud container clusters create-auto ${CLUSTER_NAME} \
    --location=${CONTROL_PLANE_REGION} \
    --release-channel=rapid \
    --enable-ray-operator

Rufen Sie Anmeldedaten für Ihren Cluster ab:

gcloud container clusters get-credentials ${CLUSTER_NAME} \
    --location=${CONTROL_PLANE_REGION}

Standard

Standardcluster erstellen:

gcloud container clusters create ${CLUSTER_NAME} \
    --location=${CONTROL_PLANE_REGION} \
    --enable-dataplane-v2 \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --enable-ip-alias \
    --enable-multi-networking \
    --addons=RayOperator,GcsFuseCsiDriver \
    --machine-type=c2-standard-16 \
    --num-nodes=1 \
    --min-nodes=1 \
    --max-nodes=5 \
    --enable-autoscaling \
    --project=${PROJECT_ID}

Rufen Sie Anmeldedaten für Ihren Cluster ab:

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

Erstellen Sie den GPU-Knotenpool. In diesen Knotenpools wird Ihre Reservierung verwendet, um die Verfügbarkeit zu gewährleisten. Sie beginnen mit zwei Knoten:

CMD=(
  gcloud container node-pools create gpu-pool
  --cluster="${CLUSTER_NAME}"
  --location="${CONTROL_PLANE_REGION}"
  --node-locations="${NODE_ZONE}"
  --machine-type="${MACHINE_TYPE}"
  --accelerator="type=${GPU_TYPE},count=8,gpu-driver-version=DEFAULT"
  --enable-autoscaling
  --num-nodes=2
  --total-max-nodes=10
  --additional-node-network="network=${GVNIC_NETWORK_PREFIX}-net,subnetwork=${GVNIC_NETWORK_PREFIX}-sub"
  --additional-node-network="network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-0"
  --additional-node-network="network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-1"
  --additional-node-network="network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-2"
  --additional-node-network="network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-3"
  --additional-node-network="network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-4"
  --additional-node-network="network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-5"
  --additional-node-network="network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-6"
  --additional-node-network="network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-7"
  --project="${PROJECT_ID}"
)

if [ -n "${RESERVATION:-}" ]; then
  CMD+=("--reservation-affinity=specific" "--reservation=${RESERVATION}")
else
  CMD+=("--reservation-affinity=none")
fi

"${CMD[@]}"

Installieren Sie das NCCL RDMA-Installationsprogramm, das für Standardcluster verwendet wird:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/gpudirect-rdma/nccl-rdma-installer.yaml

A4X

Erstellen Sie einen GKE-Cluster und einen Knotenpool mit dem Cluster Toolkitgke-a4x-Blueprint. Mit dem Blueprint wird der GKE-Cluster bereitgestellt, einschließlich des A4X-Knotenpools, der an Ihre Reservierung gebunden ist, der Beschleunigernetzwerke (ein zusätzliches gVNIC plus vier RDMA-Rails) und des verwalteten DRANET-Treibers, der die CX-7-NICs als DRA-Geräte verfügbar macht.

Konfigurieren Sie die Parameter (z. B. PROJECT_ID, CONTROL_PLANE_REGION, NODE_ZONE, Reservierung und NUM_GPU_NODES) anhand der Bereitstellungsanleitung des Blueprints und stellen Sie dann den Cluster bereit. Alternativ können Sie einen Cluster manuell erstellen. Folgen Sie dazu der Anleitung zum Erstellen von GKE-Cluster-Clustern.
1. Rufen Sie Anmeldedaten für Ihren Cluster ab:
```
gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${CONTROL_PLANE_REGION}
```
Prüfen Sie, ob der Cluster RDMA-NICs über DRA bereitstellt:
```
kubectl get deviceclasses
```
Die Ausgabe muss mrdma.google.com enthalten.

Prüfen Sie, ob die A4X-Knoten vorhanden sind:

kubectl get nodes -l cloud.google.com/gke-accelerator=nvidia-gb200

Installieren Sie das gIB-NCCL-Plug-in (A4X-Variante):

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-rdma/nccl-rdma-installer-a4x.yaml

Installieren Sie den NVIDIA DRA-Treiber, der ComputeDomain-Kanäle (IMEX) für Multi-Node-NVLink bereitstellt:

helm repo add nvidia https://helm.ngc.nvidia.com/nvidia && helm repo update
kubectl create namespace nvidia-dra-driver-gpu
kubectl apply -f - <<EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: nvidia-dra-driver-gpu-quota
  namespace: nvidia-dra-driver-gpu
spec:
  hard:
    pods: "$((2 * NUM_GPU_NODES + 1))"
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
      - system-node-critical
      - system-cluster-critical
EOF
helm upgrade --install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \
  --version=25.3.1 --namespace nvidia-dra-driver-gpu \
  --set nvidiaDriverRoot=/home/kubernetes/bin/nvidia \
  --set resources.gpus.enabled=false \
  --set kubeletPlugin.tolerations[0].key=nvidia.com/gpu \
  --set kubeletPlugin.tolerations[0].operator=Exists \
  --set kubeletPlugin.tolerations[1].key=kubernetes.io/arch \
  --set kubeletPlugin.tolerations[1].operator=Exists

Installieren Sie den KubeRay-Operator, der auf den Arbeitslast-Namespace beschränkt ist:

kubectl create namespace ${NAMESPACE}
helm repo add kuberay https://ray-project.github.io/kuberay-helm/ && helm repo update
helm upgrade --install kuberay-operator kuberay/kuberay-operator \
  --namespace ${NAMESPACE} \
  --set singleNamespaceInstall=true --set "watchNamespace={${NAMESPACE}}"

Netzwerkzuordnungen konfigurieren (nur GKE Standard – A4 und A3 Ultra)

A4 und A3 Ultra

Autopilot

Dieser Schritt ist nur für GKE Standard-GPU-Konfigurationen (nur A4 und A3 Ultra) erforderlich. Wenn Sie A4X (GB200) verwenden, verwaltet GKE Netzwerkschnittstellen automatisch. Überspringen Sie diesen Abschnitt.

Standard

Prüfen Sie das network-mapping.yaml-Manifest:

apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: gvnic-1
spec:
  vpc: ${GVNIC_NETWORK_PREFIX}-net
  vpcSubnet: ${GVNIC_NETWORK_PREFIX}-sub
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: gvnic-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: gvnic-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-0
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-0
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-0
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-0
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-1
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-1
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-2
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-2
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-2
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-2
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-3
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-3
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-3
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-3
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-4
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-4
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-4
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-4
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-5
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-5
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-5
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-5
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-6
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-6
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-6
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-6
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-7
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-7
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-7
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-7

Wenden Sie das Manifest an:

envsubst < network-mapping.yaml | kubectl apply -f -

A4X

Dieser Schritt ist nur für GKE Standard-GPU-Konfigurationen (nur A4 und A3 Ultra) erforderlich. Wenn Sie A4X (GB200) verwenden, verwaltet GKE die Netzwerkschnittstellen automatisch. Überspringen Sie diesen Abschnitt.

Daten und Speicher vorbereiten

Cloud Storage- und Kubernetes-Ressourcen konfigurieren:

Erstellen Sie einen Cloud Storage-Bucket:

gcloud storage buckets create "gs://${GS_BUCKET}" \
  --location="${CONTROL_PLANE_REGION}" \
  --project="${PROJECT_ID}" \
  --enable-hierarchical-namespace \
  --uniform-bucket-level-access

Erstellen Sie ein Kubernetes-Dienstkonto (Kubernetes Service Account, KSA) und binden Sie es an den Bucket:

kubectl create serviceaccount ${KSA_NAME} -n ${NAMESPACE}
gcloud storage buckets add-iam-policy-binding "gs://${GS_BUCKET}" \
  --member="principal://iam.googleapis.com/projects/${PROJECT_NUMBER}/locations/global/workloadIdentityPools/${PROJECT_ID}.svc.id.goog/subject/ns/${NAMESPACE}/sa/${KSA_NAME}" \
  --role="roles/storage.objectUser"

Secret für Hugging Face erstellen:

kubectl create secret generic hf-secret --from-literal=hf_token=${HF_TOKEN}

Prüfen Sie das gcsfuse-storage.yaml-Manifest:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: training-bucket-pv
spec:
  accessModes:
  -   ReadWriteMany
  capacity:
    storage: 768Gi
  persistentVolumeReclaimPolicy: Delete
  storageClassName: gcsfuse-sc
  mountOptions:
  -   implicit-dirs
  -   metadata-cache:negative-ttl-secs:0
  -   metadata-cache:ttl-secs:0
  -   metadata-cache:stat-cache-max-size-mb:-1
  -   metadata-cache:type-cache-max-size-mb:-1
  -   file-cache:max-size-mb:-1
  -   file-cache:cache-file-for-range-read:true
  -   file-cache:enable-parallel-downloads:true
  -   read_ahead_kb=1024
  -   write:enable-streaming-writes:true
  -   write:global-max-blocks:200000
  csi:
    driver: gcsfuse.csi.storage.gke.io
    volumeHandle: ${GS_BUCKET}
    volumeAttributes:
      skipCSIBucketAccessCheck: "true"
      gcsfuseMetadataPrefetchOnMount: "true"
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: training-bucket-pvc
spec:
  accessModes:
  -   ReadWriteMany
  resources:
    requests:
      storage: 768Gi
  storageClassName: gcsfuse-sc

Wenden Sie das Manifest an:

envsubst < gcsfuse-storage.yaml | kubectl apply -f -

DRANET einrichten

DRANET konfigurieren:

A4 und A3 Ultra

Autopilot

ComputeClass-Manifest erstellen:

echo "Generating computeclass-dranet.yaml..."
cat <<EOF > computeclass-dranet.yaml
apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: dranet-a4-computeclass-v3
spec:
  nodePoolAutoCreation:
    enabled: true
  nodePoolConfig:
    dra:
      networking:
        enabled: true
  priorities:
  - machineType: ${MACHINE_TYPE}
    gpu:
      count: 8
      type: ${GPU_TYPE}
    acceleratorNetworkProfile: auto
EOF

if [ -n "${RESERVATION:-}" ]; then
  echo "Adding reservation affinity for ${RESERVATION} to ComputeClass..."
  cat <<EOF >> computeclass-dranet.yaml
    reservations:
      affinity: Specific
      specific:
      - name: ${RESERVATION}
        project: ${PROJECT_ID}
EOF
fi

Wenden Sie sowohl das computeclass-dranet.yaml-Manifest (das Sie im vorherigen Schritt erstellt haben) als auch das resourceclaim-dranet.yaml-Manifest (das im Beispiel-Repository enthalten ist) an:
```
echo "Applying ComputeClass..."
kubectl apply -f computeclass-dranet.yaml

echo "Applying ResourceClaimTemplate..."
kubectl apply -f resourceclaim-dranet.yaml
```

Standard

Es ist keine DRANET-Einrichtung erforderlich. Sie können direkt mit dem nächsten Abschnitt fortfahren.

A4X

DRANET wird vom Cluster Toolkit festgelegt. Sie können direkt mit dem nächsten Abschnitt fortfahren.

Modell und Daten vorbereiten

Füllen Sie Ihren Cloud Storage-Bucket mit den Modellgewichten und Datasets. Sie können diese Befehle lokal oder in einem GKE-Pod ausführen, um den Bucket zu füllen:

A4 und A3 Ultra

Autopilot

Datenaufbereitungsjob prüfen:

apiVersion: batch/v1
kind: Job
metadata:
  name: data-prep-job
  namespace: ${NAMESPACE}
spec:
  template:
    metadata:
      annotations:
        gke-gcsfuse/volumes: "true"
        gke-gcsfuse/cpu-limit: "2"
        gke-gcsfuse/memory-limit: "4Gi"
        gke-gcsfuse/ephemeral-storage-limit: "50Gi"
    spec:
      serviceAccountName: ${KSA_NAME}
      restartPolicy: OnFailure
      nodeSelector:
        cloud.google.com/compute-class: Performance
      containers:
      - name: prep-data
        image: verlai/verl:vllm011.latest
        resources:
          requests:
            cpu: "4"
            memory: "8Gi"
            ephemeral-storage: "50Gi"
          limits:
            cpu: "4"
            memory: "8Gi"
            ephemeral-storage: "50Gi"
        env:
        - name: HF_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_token
        - name: HF_HOME
          value: /data/.cache/huggingface
        - name: HF_HUB_DISABLE_XET
          value: "1"
        command: ["/bin/bash", "-c"]
        args:
        - |
          set -euo pipefail

          # Clone verl to GCS (for worker pods)
          if [ ! -d "/data/verl" ]; then
            echo "Cloning verl to GCS..."
            git clone --branch v0.6.1 https://github.com/volcengine/verl.git /data/verl
          else
            echo "verl already exists in /data/verl"
          fi

          # Clone verl locally for fast installation
          echo "Cloning verl locally..."
          git clone --branch v0.6.1 https://github.com/volcengine/verl.git /tmp/verl

          # Install verl package from local clone
          echo "Installing verl package..."
          pip3 install --no-cache-dir --no-deps /tmp/verl
          rm -rf /tmp/verl

          # Preprocess GSM8K
          if [ ! -d "/data/gsm8k" ]; then
            echo "Preprocessing GSM8K..."
            python /data/verl/examples/data_preprocess/gsm8k.py --local_save_dir /data/gsm8k
          else
            echo "GSM8K data already exists in /data/gsm8k"
          fi

          # Download model
          if [ ! -d "/data/Qwen2.5-32B-Instruct" ]; then
            echo "Downloading Qwen2.5-32B-Instruct..."
            huggingface-cli download Qwen/Qwen2.5-32B-Instruct --local-dir /data/Qwen2.5-32B-Instruct --local-dir-use-symlinks False
          else
            echo "Model Qwen2.5-32B-Instruct already exists in /data/Qwen2.5-32B-Instruct"
          fi

          echo "Data preparation complete!"
        volumeMounts:
        - name: training-bucket-vol
          mountPath: /data
      volumes:
      - name: training-bucket-vol
        persistentVolumeClaim:
          claimName: training-bucket-pvc

Starten Sie den Job:

envsubst < "data-prep-job.yaml" | kubectl apply -f -

Job überwachen:

kubectl logs -n ${NAMESPACE} -l job-name=data-prep-job -f

Standard

Datenaufbereitungsjob prüfen:

apiVersion: batch/v1
kind: Job
metadata:
  name: data-prep-job
  namespace: ${NAMESPACE}
spec:
  template:
    metadata:
      annotations:
        gke-gcsfuse/volumes: "true"
        gke-gcsfuse/cpu-limit: "2"
        gke-gcsfuse/memory-limit: "4Gi"
        gke-gcsfuse/ephemeral-storage-limit: "20Gi"
    spec:
      serviceAccountName: ${KSA_NAME}
      restartPolicy: OnFailure
      nodeSelector:
        cloud.google.com/gke-nodepool: "default-pool"
      containers:
      - name: prep-data
        image: verlai/verl:vllm011.latest
        resources:
          requests:
            cpu: "4"
            memory: "8Gi"
            ephemeral-storage: "10Gi"
          limits:
            cpu: "4"
            memory: "8Gi"
            ephemeral-storage: "10Gi"
        env:
        - name: HF_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_token
        - name: HF_HOME
          value: /data/.cache/huggingface
        - name: HF_HUB_DISABLE_XET
          value: "1"
        command: ["/bin/bash", "-c"]
        args:
        - |
          set -euo pipefail

          # Clone verl to GCS (for worker pods)
          if [ ! -d "/data/verl" ]; then
            echo "Cloning verl to GCS..."
            git clone --branch v0.6.1 https://github.com/volcengine/verl.git /data/verl
          else
            echo "verl already exists in /data/verl"
          fi

          # Clone verl locally for fast installation
          echo "Cloning verl locally..."
          git clone --branch v0.6.1 https://github.com/volcengine/verl.git /tmp/verl

          # Install verl package from local clone
          echo "Installing verl package..."
          pip3 install --no-cache-dir --no-deps /tmp/verl
          rm -rf /tmp/verl

          # Preprocess GSM8K
          if [ ! -d "/data/gsm8k" ]; then
            echo "Preprocessing GSM8K..."
            python /data/verl/examples/data_preprocess/gsm8k.py --local_save_dir /data/gsm8k
          else
            echo "GSM8K data already exists in /data/gsm8k"
          fi

          # Download model
          if [ ! -d "/data/Qwen2.5-32B-Instruct" ]; then
            echo "Downloading Qwen2.5-32B-Instruct..."
            huggingface-cli download Qwen/Qwen2.5-32B-Instruct --local-dir /data/Qwen2.5-32B-Instruct --local-dir-use-symlinks False
          else
            echo "Model Qwen2.5-32B-Instruct already exists in /data/Qwen2.5-32B-Instruct"
          fi

          echo "Data preparation complete!"
        volumeMounts:
        - name: training-bucket-vol
          mountPath: /data
      volumes:
      - name: training-bucket-vol
        persistentVolumeClaim:
          claimName: training-bucket-pvc

Starten Sie den Job:

envsubst < "${SCRIPT_DIR}/data-prep-job.yaml" | kubectl apply -f -

Job überwachen:

kubectl logs -n ${NAMESPACE} -l job-name=data-prep-job -f

A4X

Klonen Sie das verl-Repository, bereiten Sie die virtuelle Umgebung vor und verarbeiten Sie das GSM8K-Dataset:

git clone https://github.com/volcengine/verl.git
git -C verl checkout ${VERL_REF}

VENV_DIR=.venv
python3 -m venv $VENV_DIR
source $VENV_DIR/bin/activate
pip install verl

python verl/examples/data_preprocess/gsm8k.py --local_save_dir ~/data/gsm8k

Laden Sie das Modell Qwen2.5-32B-Instruct mit der Hugging Face-CLI herunter. Für diesen Download sind etwa 66 GB Speicherplatz erforderlich:
```
hf download Qwen/Qwen2.5-32B-Instruct --local-dir Qwen2.5-32B-Instruct
```

Laden Sie das Modell, die Daten und den verl-Code in Ihren Cloud Storage-Bucket hoch:

gcloud storage cp --recursive verl gs://${GS_BUCKET}/verl
gcloud storage cp --recursive Qwen2.5-32B-Instruct gs://${GS_BUCKET}/Qwen2.5-32B-Instruct
gcloud storage cp --recursive ~/data/gsm8k/* gs://${GS_BUCKET}/gsm8k/

Benutzerdefinierte RayCluster-Ressource bereitstellen

Stellen Sie eine benutzerdefinierte RayCluster-Ressource bereit, die aus einem System-Head-Pod und mehreren GPU-gestützten Worker-Pods besteht.

A4 und A3 Ultra

Wählen Sie den GKE-Clustermodus aus, den Sie zum Erstellen Ihres Clusters verwendet haben:

Autopilot

RayCluster-Arbeitslast prüfen:

apiVersion: ray.io/v1
kind: RayCluster
metadata:
  name: b200-ray-cluster-dranet
spec:
  rayVersion: '2.47.0'
  headGroupSpec:
    rayStartParams:
      dashboard-host: '0.0.0.0'
    template:
      metadata:
        annotations:
          gke-gcsfuse/volumes: "true"
      spec:
        serviceAccountName: ${KSA_NAME}
        nodeSelector:
          cloud.google.com/gke-spot: "true"
          cloud.google.com/machine-family: "c2"
          cloud.google.com/compute-class: Performance
        containers:
        - name: ray-head
          image: verlai/verl:vllm011.latest 
          ports:
            - containerPort: 6379
              name: gcs-server
            - containerPort: 8265
              name: dashboard
            - containerPort: 10001
              name: client
          resources:
            limits:
              cpu: "12"
              memory: "32G"
              ephemeral-storage: "9Gi"
            requests:
              cpu: "12"
              memory: "32G"
              ephemeral-storage: "9Gi"
          volumeMounts:
            - mountPath: /tmp/ray
              name: ray-logs
            - name: training-bucket-vol
              mountPath: /data
        volumes:
          - name: ray-logs
            emptyDir: {}
          - name: training-bucket-vol
            persistentVolumeClaim:
              claimName: training-bucket-pvc
  workerGroupSpecs:
  - replicas: 2
    minReplicas: 2
    maxReplicas: 2
    groupName: gpu-group
    rayStartParams:
      num-cpus: "220"
    template:
      metadata:
        annotations:
          gke-gcsfuse/volumes: "true"
      spec:
        resourceClaims:
          - name: rdma-claim
            resourceClaimTemplateName: all-mrdma
        initContainers:
        - name: verl-setup
          image: verlai/verl:vllm011.latest
          command: ["/bin/bash", "-c"]
          args:
            - |
              echo "Performing local editable install..."
              cd /data/verl && pip3 install --no-deps -e .
          volumeMounts:
          - name: training-bucket-vol
            mountPath: /data
        serviceAccountName: ${KSA_NAME}
        nodeSelector:
          cloud.google.com/compute-class: dranet-a4-computeclass-v3
        tolerations:
          - key: "nvidia.com/gpu"
            operator: "Exists"
            effect: "NoSchedule"
        containers:
        - name: ray-worker
          image: verlai/verl:vllm011.latest
          env:
           - name: LD_LIBRARY_PATH
             value: /usr/local/nvidia/lib64
          resources:
            limits:
              cpu: "180"
              memory: "2000Gi"
              nvidia.com/gpu: "8"
              ephemeral-storage: "1000Gi"
            requests:
              cpu: "180"
              memory: "2000Gi"
              nvidia.com/gpu: "8"
              ephemeral-storage: "1000Gi"
            claims:
            - name: rdma-claim
          volumeMounts:
          - name: shared-memory
            mountPath: /dev/shm
          - name: ray-tmp-storage
            mountPath: /tmp
          - name: training-bucket-vol
            mountPath: /data
        volumes:
        - name: shared-memory
          emptyDir:
            medium: "Memory"
            sizeLimit: 250Gi 
        - name: ray-tmp-storage
          emptyDir: {}
        - name: training-bucket-vol
          persistentVolumeClaim:
            claimName: training-bucket-pvc

Wenden Sie den RayCluster an:

envsubst < "ray-cluster-auto-dranet.yaml" | kubectl apply -f -

Standard

RayCluster-Arbeitslast prüfen:

apiVersion: ray.io/v1
kind: RayCluster
metadata:
  name: b200-ray-cluster
  annotations:
spec:
  rayVersion: '2.47.0'
  headGroupSpec:
    rayStartParams:
      dashboard-host: '0.0.0.0'
    template:
      metadata:
        annotations:
          gke-gcsfuse/volumes: "true"
      spec:
        serviceAccountName: ${KSA_NAME}
        nodeSelector:
          cloud.google.com/gke-nodepool: "default-pool"
        containers:
        - name: ray-head
          image: verlai/verl:vllm011.latest 
          ports:
            - containerPort: 6379
              name: gcs-server
            - containerPort: 8265
              name: dashboard
            - containerPort: 10001
              name: client
          resources:
            limits:
              cpu: "12"
              memory: "32G"
              ephemeral-storage: "9Gi"
            requests:
              cpu: "12"
              memory: "32G"
              ephemeral-storage: "9Gi"
          volumeMounts:
            - mountPath: /tmp/ray
              name: ray-logs
            - name: training-bucket-vol
              mountPath: /data
        volumes:
          - name: ray-logs
            emptyDir: {}
          - name: training-bucket-vol
            persistentVolumeClaim:
              claimName: training-bucket-pvc
  workerGroupSpecs:
  - replicas: 2
    minReplicas: 2
    maxReplicas: 2
    groupName: gpu-group
    rayStartParams:
      num-cpus: "220"
    template:
      metadata:
        annotations:
          gke-gcsfuse/volumes: "true"
          networking.gke.io/default-interface: 'eth0'
          networking.gke.io/interfaces: |
            [
              {"interfaceName":"eth0","network":"default"},
              {"interfaceName":"eth1","network":"gvnic-1"},
              {"interfaceName":"eth2","network":"rdma-0"},
              {"interfaceName":"eth3","network":"rdma-1"},
              {"interfaceName":"eth4","network":"rdma-2"},
              {"interfaceName":"eth5","network":"rdma-3"},
              {"interfaceName":"eth6","network":"rdma-4"},
              {"interfaceName":"eth7","network":"rdma-5"},
              {"interfaceName":"eth8","network":"rdma-6"},
              {"interfaceName":"eth9","network":"rdma-7"}
            ]
      spec:
        initContainers:
        - name: verl-setup
          image: verlai/verl:vllm011.latest
          command: ["/bin/bash", "-c"]
          args:
            - |
              echo "Performing local editable install..."
              cd /data/verl && pip3 install --no-deps -e .
          volumeMounts:
          - name: training-bucket-vol
            mountPath: /data
        serviceAccountName: ${KSA_NAME}
        nodeSelector:
          cloud.google.com/gke-accelerator: ${GPU_TYPE}
        tolerations:
          - key: "nvidia.com/gpu"
            operator: "Exists"
            effect: "NoSchedule"
        containers:
        - name: ray-worker
          image: verlai/verl:vllm011.latest
          env:
           - name: LD_LIBRARY_PATH
             value: /usr/local/nvidia/lib64
          resources:
            limits:
              cpu: "220"
              memory: "2800Gi"
              nvidia.com/gpu: "8"
              ephemeral-storage: "1000Gi"
            requests:
              cpu: "220"
              memory: "2800Gi"
              nvidia.com/gpu: "8"
              ephemeral-storage: "1000Gi"
          volumeMounts:
          - name: nvidia
            mountPath: /usr/local/nvidia
          - name: gib
            mountPath: /usr/local/gib
          - name: shared-memory
            mountPath: /dev/shm
          - name: ray-tmp-storage
            mountPath: /tmp
          - name: training-bucket-vol
            mountPath: /data
        volumes:
        - name: gib
          hostPath:
            path: /home/kubernetes/bin/gib
        - name: nvidia
          hostPath:
            path: /home/kubernetes/bin/nvidia
        - name: lib64
          hostPath:
            path: /lib64
        - name: shared-memory
          emptyDir:
            medium: "Memory"
            sizeLimit: 250Gi 
        - name: sys
          hostPath:
            path: /sys
        - name: proc-sys
          hostPath:
            path: /proc/sys
        - name: ray-tmp-storage
          emptyDir: {}
        - name: training-bucket-vol
          persistentVolumeClaim:
            claimName: training-bucket-pvc

Wenden Sie den RayCluster an:

envsubst < "ray-cluster-standard.yaml" | kubectl apply -f -

A4X

Erstellen Sie das RDMA-ResourceClaimTemplate und das NVIDIA-ComputeDomain. Jeder GPU-Worker-Pod beansprucht vier RDMA-NICs (alle Rails des Knotens) und einen IMEX-Channel. Speichern Sie das folgende Manifest unter compute-domain-a4x.yaml:

apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: verl-rdma-nic
  namespace: ${NAMESPACE}
spec:
  spec:
    devices:
      requests:
      - name: nic
        exactly:
          deviceClassName: mrdma.google.com
          allocationMode: ExactCount
          count: 1
---
apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: verl-compute-domain
  namespace: ${NAMESPACE}
spec:
  numNodes: ${NUM_GPU_NODES}
  channel:
    resourceClaimTemplate:
      name: verl-compute-domain-channel

Wenden Sie das Manifest an:

kubectl apply -f compute-domain-a4x.yaml

Stellen Sie den Ray-Cluster bereit. Der Ray-Head-Pod wird auf einem A4X-Knoten ausgeführt, ohne GPUs anzufordern, da das Image nur arm64 ist. Speichern Sie die folgenden Konfigurationen in ray-cluster-a4x.yaml:

apiVersion: ray.io/v1
kind: RayCluster
metadata:
  name: gb200-ray-cluster
  namespace: ${NAMESPACE}
spec:
  rayVersion: '2.49.0'
  headGroupSpec:
    rayStartParams:
      dashboard-host: '0.0.0.0'
      num-cpus: "0"
    template:
      metadata:
        annotations:
          gke-gcsfuse/volumes: "true"
      spec:
        serviceAccountName: ${KSA_NAME}
        nodeSelector:
          cloud.google.com/gke-accelerator: nvidia-gb200
        tolerations:
        - key: nvidia.com/gpu
          operator: Exists
          effect: NoSchedule
        - key: kubernetes.io/arch
          operator: Exists
          effect: NoSchedule
        containers:
        - name: ray-head
          image: ${VERL_IMAGE}
          lifecycle:
            postStart:
              exec:
                command:
                - /bin/bash
                - -c
                - pip3 install --quiet TransferQueue==0.1.8
          ports:
          - containerPort: 6379
            name: gcs-server
          - containerPort: 8265
            name: dashboard
          - containerPort: 10001
            name: client
          resources:
            limits:
              cpu: "12"
              memory: 32Gi
              ephemeral-storage: 20Gi
            requests:
              cpu: "12"
              memory: 32Gi
              ephemeral-storage: 20Gi
          volumeMounts:
          - mountPath: /tmp/ray
            name: ray-logs
          - name: training-bucket-vol
            mountPath: /data
        volumes:
        - name: ray-logs
          emptyDir: {}
        - name: training-bucket-vol
          persistentVolumeClaim:
            claimName: training-bucket-pvc
  workerGroupSpecs:
  - replicas: ${NUM_GPU_NODES}
    minReplicas: ${NUM_GPU_NODES}
    maxReplicas: ${NUM_GPU_NODES}
    groupName: gpu-group
    rayStartParams:
      num-cpus: "120"
    template:
      metadata:
        annotations:
          gke-gcsfuse/volumes: "true"
      spec:
        serviceAccountName: ${KSA_NAME}
        nodeSelector:
          cloud.google.com/gke-accelerator: nvidia-gb200
        affinity:
          podAntiAffinity:
            requiredDuringSchedulingIgnoredDuringExecution:
            - labelSelector:
                matchLabels:
                  ray.io/group: gpu-group
              topologyKey: kubernetes.io/hostname
        tolerations:
        - key: nvidia.com/gpu
          operator: Exists
          effect: NoSchedule
        - key: kubernetes.io/arch
          operator: Exists
          effect: NoSchedule
        containers:
        - name: ray-worker
          image: ${VERL_IMAGE}
          lifecycle:
            postStart:
              exec:
                command:
                - /bin/bash
                - -c
                - pip3 install --quiet TransferQueue==0.1.8
          env:
          - name: LD_LIBRARY_PATH
            value: /usr/local/nvidia/lib64
          resources:
            limits:
              cpu: "120"
              memory: 600Gi
              nvidia.com/gpu: "4"
              ephemeral-storage: 500Gi
            requests:
              cpu: "120"
              memory: 600Gi
              nvidia.com/gpu: "4"
              ephemeral-storage: 500Gi
            claims:
            - name: rdma-nic-0
            - name: rdma-nic-1
            - name: rdma-nic-2
            - name: rdma-nic-3
            - name: compute-domain-channel
          volumeMounts:
          - name: nvidia
            mountPath: /usr/local/nvidia
          - name: gib
            mountPath: /usr/local/gib
          - name: shared-memory
            mountPath: /dev/shm
          - name: ray-tmp-storage
            mountPath: /tmp
          - name: training-bucket-vol
            mountPath: /data
        resourceClaims:
        - name: rdma-nic-0
          resourceClaimTemplateName: verl-rdma-nic
        - name: rdma-nic-1
          resourceClaimTemplateName: verl-rdma-nic
        - name: rdma-nic-2
          resourceClaimTemplateName: verl-rdma-nic
        - name: rdma-nic-3
          resourceClaimTemplateName: verl-rdma-nic
        - name: compute-domain-channel
          resourceClaimTemplateName: verl-compute-domain-channel
        volumes:
        - name: gib
          hostPath:
            path: /home/kubernetes/bin/gib
        - name: nvidia
          hostPath:
            path: /home/kubernetes/bin/nvidia
        - name: shared-memory
          emptyDir:
            medium: Memory
            sizeLimit: 200Gi
        - name: ray-tmp-storage
          emptyDir: {}
        - name: training-bucket-vol
          persistentVolumeClaim:
            claimName: training-bucket-pvc

Wenden Sie das RayCluster-Manifest an:

envsubst < ray-cluster-a4x.yaml | kubectl apply -f -

Warten Sie, bis sich ein Head-Pod und vier Worker-Pods im Status Running befinden:
```
kubectl get pods -w
```

GRPO-Job starten

Konfigurieren und senden Sie den Trainingsjob für das bestärkende Lernen:

A4 und A3 Ultra

Ray Client einrichten:

if [ ! -d "env" ]; then
  virtualenv -p $(which python3) env
else
  echo "Found virtual environment env, not recreating"
fi
source env/bin/activate
pip3 install ray[default]

Ray-Head-Dienst wiederherstellen:

SVC_NAME="$(kubectl get svc -l "ray.io/node-type=head" -o jsonpath='{..metadata.name}')"
echo "Ray head service name: ${SVC_NAME}"

Richten Sie die Portweiterleitung zum Ray-Dashboard-Knoten ein. Verwenden Sie für diesen Schritt ein separates Terminalfenster, da dieser Befehl das Terminal blockiert, während er ausgeführt wird. Drücken Sie Strg+C, um den Vorgang zu beenden:
```
echo "Starting port-forwarding to ${SVC_NAME} on port 8265..."
kubectl port-forward svc/"${SVC_NAME}" 8265:8265 -n "${NAMESPACE}" &
```

Prüfen Sie das runtime-env.yaml-Manifest:

py_modules: ["."]
working_dir": "."
py_executable": "uv run"
setup_hook: runtime_env.uv_runtime_env_hook.hook 
env_vars:
  PYTHONPATH: "/data/verl"
  LD_LIBRARY_PATH: "/usr/local/nvidia/lib64"
  NCCL_DEBUG: "INFO"
  NUM_WORKERS: "2"
  CPUS_PER_WORKER: "192"
  GPUS_PER_WORKER: "8"
  NCCL_NET_PLUGIN: "/usr/local/gib/lib64/libnccl-net_internal.so"
  NCCL_CROSS_NIC: "0"
  NCCL_NET_GDR_LEVEL: "PIX"
  NCCL_P2P_NET_CHUNKSIZE: "131072"
  NCCL_NVLS_CHUNKSIZE: "524288"
  NCCL_IB_ADAPTIVE_ROUTING: "1"
  NCCL_IB_QPS_PER_CONNECTION: "4"
  NCCL_IB_TC: "52"
  NCCL_IB_FIFO_TC: "84"
  NCCL_TUNER_CONFIG_PATH: "/usr/local/gib/configs/tuner_config_a4.txtpb" 
  HF_HOME: "/data/huggingface_cache"
  GLOO_SOCKET_IFNAME: "eth0" 
pip:
  packages:
    - torch 
    - torchvision
    - TransferQueue

Wenn Sie H200-GPUs verwenden, ändern Sie NCCL_TUNER_CONFIG_PATH in /usr/local/gib/configs/tuner_config_a3u.txtpb.

Diese Datei wird vom Ray-Client verwendet. Sie müssen dieses Manifest nicht auf den Cluster anwenden.

Senden Sie den Job mit ray job submit:

ray job submit \
  --address "http://localhost:8265" \
  --runtime-env runtime-env.yaml \
    -- \
    bash -c "
        cd /data/verl && PYTHONUNBUFFERED=1 python3 -m verl.trainer.main_ppo \
        data.train_files=/data/gsm8k/train.parquet \
        data.val_files=/data/gsm8k/test.parquet \
        data.train_batch_size=256 \
        data.max_prompt_length=512 \
        data.max_response_length=512 \
        actor_rollout_ref.model.path=/data/Qwen2.5-32B-Instruct \
        actor_rollout_ref.actor.optim.lr=1e-5 \
        actor_rollout_ref.actor.ppo_mini_batch_size=256 \
        actor_rollout_ref.actor.ppo_micro_batch_size_per_gpu=64 \
        actor_rollout_ref.rollout.name=vllm \
        actor_rollout_ref.rollout.log_prob_micro_batch_size_per_gpu=8 \
        actor_rollout_ref.rollout.tensor_model_parallel_size=8 \
        actor_rollout_ref.rollout.gpu_memory_utilization=0.6 \
        actor_rollout_ref.ref.log_prob_micro_batch_size_per_gpu=4 \
        actor_rollout_ref.actor.strategy=fsdp2 \
        algorithm.kl_ctrl.kl_coef=0.001 \
        trainer.logger=console \
        trainer.val_before_train=False \
        trainer.n_gpus_per_node=8 \
        trainer.nnodes=2 \
        trainer.save_freq=10 \
        trainer.test_freq=10 \
        trainer.default_local_dir=/data/verl/checkpoints \
        algorithm.adv_estimator=grpo \
        actor_rollout_ref.rollout.n=8 \
        trainer.total_epochs=2"

Behalten Sie die Logs im Ray-Dashboard oder in der Konsolenausgabe im Blick. Achten Sie auf eine Steigerung von critic/score/mean, die auf Lernen hindeutet.

Nach Abschluss des Trainings befinden sich die Prüfpunkte des trainierten Modells in gs://$GS_BUCKET/verl/checkpoints.

A4X

Rufen Sie den Namen des Ray-Head-Pods ab:

export HEAD_POD=$(kubectl get pod -n ${NAMESPACE} -l ray.io/node-type=head -o jsonpath='{.items[0].metadata.name}')

Konfigurieren Sie die Ray-Laufzeitumgebungsdatei direkt im Haupt-Pod:

kubectl exec ${HEAD_POD} -c ray-head -- bash -c 'mkdir -p /tmp/submit && cat > /tmp/submit/runtime-env.yaml <<EOF
working_dir: "."
env_vars:
  PYTHONPATH: "/data/verl"
  LD_LIBRARY_PATH: "/usr/local/nvidia/lib64:/usr/local/gib/lib64"
  NCCL_DEBUG: "INFO"
  NCCL_ENV_PLUGIN: "gcp"
  HF_HOME: "/data/huggingface_cache"
  GLOO_SOCKET_IFNAME: "eth0"
EOF'

Senden Sie den GRPO-Trainingsjob, indem Sie ihn auf dem Ray-Head-Pod ausführen:

kubectl exec ${HEAD_POD} -c ray-head -- bash -c 'cd /tmp/submit && \
ray job submit --runtime-env runtime-env.yaml --no-wait -- \
  python3 -m verl.trainer.main_ppo \
    algorithm.adv_estimator=grpo \
    data.train_files=/data/gsm8k/train.parquet \
    data.val_files=/data/gsm8k/test.parquet \
    data.train_batch_size=256 \
    data.max_prompt_length=512 \
    data.max_response_length=512 \
    actor_rollout_ref.model.path=/data/Qwen2.5-32B-Instruct \
    actor_rollout_ref.actor.optim.lr=1e-5 \
    actor_rollout_ref.actor.ppo_mini_batch_size=64 \
    actor_rollout_ref.actor.ppo_micro_batch_size_per_gpu=8 \
    actor_rollout_ref.actor.use_kl_loss=True \
    actor_rollout_ref.actor.strategy=fsdp2 \
    actor_rollout_ref.rollout.name=vllm \
    actor_rollout_ref.rollout.tensor_model_parallel_size=4 \
    actor_rollout_ref.rollout.gpu_memory_utilization=0.6 \
    actor_rollout_ref.rollout.n=8 \
    actor_rollout_ref.rollout.log_prob_micro_batch_size_per_gpu=16 \
    actor_rollout_ref.ref.log_prob_micro_batch_size_per_gpu=16 \
    algorithm.kl_ctrl.kl_coef=0.001 \
    trainer.logger=console \
    trainer.n_gpus_per_node=4 \
    trainer.nnodes=4 \
    trainer.save_freq=10 \
    trainer.test_freq=10 \
    trainer.total_epochs=2 \
    trainer.default_local_dir=/data/verl/checkpoints'

Job-Logs überwachen (mit der eindeutigen ID, die von ray job submit zurückgegeben wird):
```
kubectl exec ${HEAD_POD} -c ray-head -- ray job logs <var>JOB_ID</var> --follow
```
Ersetzen Sie JOB_ID. Prüfen Sie, ob die NVLink-Verbindung zwischen Knoten aktiv ist. Suchen Sie dazu in Logs, die via P2P/MNNVL enthalten, nach NCCL-Zeilen.

Bereinigen

Löschen Sie die Ressourcen, um Gebühren zu vermeiden:

A4 und A3 Ultra

Autopilot

Ray-Cluster löschen:

envsubst < ray-cluster-auto-dranet.yaml | kubectl delete -f - --ignore-not-found=true || true

Löschen Sie Cloud Storage FUSE:

envsubst < gcsfuse-storage.yaml | kubectl delete -f - --ignore-not-found=true || true

Löschen Sie die DRANET-Ressourcen:

kubectl delete -f "resourceclaim-dranet.yaml" --ignore-not-found=true || true
kubectl delete -f "computeclass-dranet.yaml" --ignore-not-found=true || true

Löschen Sie den Cloud Storage-Bucket:

gcloud storage rm -r "gs://${GS_BUCKET}" || true

Löschen Sie den GKE-Cluster:

gcloud container clusters delete ${CLUSTER_NAME} --location=${CONTROL_PLANE_REGION} --quiet || true

Standard

Ray-Cluster löschen:

envsubst < "${SCRIPT_DIR}/ray-cluster-standard.yaml" | kubectl delete -f - --ignore-not-found=true || true

Löschen Sie Cloud Storage FUSE:

envsubst < "${SCRIPT_DIR}/gcsfuse-storage.yaml" | kubectl delete -f - --ignore-not-found=true || true

Löschen Sie den Cloud Storage-Bucket:

gcloud storage rm -r "gs://${GS_BUCKET}" --project="${PROJECT_ID}" || true

Löschen Sie den GKE-Cluster:

gcloud container clusters delete ${CLUSTER_NAME} --location=${CONTROL_PLANE_REGION} --project=${PROJECT_ID} --quiet || true

Löschen Sie die VPC-Netzwerke und ‑Subnetze:

# Delete RDMA subnets first
echo "Deleting RDMA subnets..."
for N in $(seq 0 7); do
  if gcloud compute networks subnets describe ${RDMA_NETWORK_PREFIX}-sub-$N --region=${CONTROL_PLANE_REGION} --project=${PROJECT_ID} >/dev/null 2>&1; then
    gcloud compute networks subnets delete ${RDMA_NETWORK_PREFIX}-sub-$N --region=${CONTROL_PLANE_REGION} --project=${PROJECT_ID} --quiet &
  fi
done
wait

# Delete RDMA network
if gcloud compute networks describe ${RDMA_NETWORK_PREFIX}-net --project=${PROJECT_ID} >/dev/null 2>&1; then
  echo "Deleting firewall rules for ${RDMA_NETWORK_PREFIX}-net..."
  for rule in $(gcloud compute firewall-rules list --filter="network:${RDMA_NETWORK_PREFIX}-net" --format="value(name)" --project=${PROJECT_ID} 2>/dev/null); do
    echo "Deleting firewall rule ${rule}..."
    gcloud compute firewall-rules delete ${rule} --project=${PROJECT_ID} --quiet || true
  done
  echo "Deleting RDMA network ${RDMA_NETWORK_PREFIX}-net..."
  gcloud compute networks delete ${RDMA_NETWORK_PREFIX}-net --project=${PROJECT_ID} --quiet || true
fi

# Delete GVNIC Firewall
if gcloud compute firewall-rules describe ${GVNIC_NETWORK_PREFIX}-internal --project=${PROJECT_ID} >/dev/null 2>&1; then
  echo "Deleting firewall rule ${GVNIC_NETWORK_PREFIX}-internal..."
  gcloud compute firewall-rules delete ${GVNIC_NETWORK_PREFIX}-internal --project=${PROJECT_ID} --quiet || true
fi

# Delete GVNIC subnet
if gcloud compute networks subnets describe ${GVNIC_NETWORK_PREFIX}-sub --region=${CONTROL_PLANE_REGION} --project=${PROJECT_ID} >/dev/null 2>&1; then
  echo "Deleting GVNIC subnet ${GVNIC_NETWORK_PREFIX}-sub..."
  gcloud compute networks subnets delete ${GVNIC_NETWORK_PREFIX}-sub --region=${CONTROL_PLANE_REGION} --project=${PROJECT_ID} --quiet || true
fi

# Delete GVNIC network
if gcloud compute networks describe ${GVNIC_NETWORK_PREFIX}-net --project=${PROJECT_ID} >/dev/null 2>&1; then
  echo "Deleting firewall rules for ${GVNIC_NETWORK_PREFIX}-net..."
  for rule in $(gcloud compute firewall-rules list --filter="network:${GVNIC_NETWORK_PREFIX}-net" --format="value(name)" --project=${PROJECT_ID} 2>/dev/null); do
    echo "Deleting firewall rule ${rule}..."
    gcloud compute firewall-rules delete ${rule} --project=${PROJECT_ID} --quiet || true
  done
  echo "Deleting GVNIC network ${GVNIC_NETWORK_PREFIX}-net..."
  gcloud compute networks delete ${GVNIC_NETWORK_PREFIX}-net --project=${PROJECT_ID} --quiet || true
fi

A4X

kubectl delete raycluster gb200-ray-cluster
kubectl delete computedomain verl-compute-domain
gcloud storage rm -r gs://${GS_BUCKET}
gcloud container clusters delete ${CLUSTER_NAME} --location=${CONTROL_PLANE_REGION}

Verstärkungslernen mit verl in GKE abstimmen und skalieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Hintergrund

Bestärkendes Lernen (Reinforcement Learning, RL)

Gruppenrelative Richtlinienoptimierung (Group Relative Policy Optimization, GRPO)

Volcano Engine Reinforcement Learning (VERL)

Ziele

Hinweis

Umgebung vorbereiten

A4 und A3 Ultra

Autopilot

Standard

A4X

A4 und A3 Ultra

Autopilot

Standard

A4X

Infrastruktur einrichten

RDMA-Netzwerk und ‑Subnetze erstellen (nur GKE Standard – A4 und A3 Ultra)

A4 und A3 Ultra

Autopilot

Standard

A4X

GKE-Cluster erstellen

A4 und A3 Ultra

Autopilot

Standard

A4X

Netzwerkzuordnungen konfigurieren (nur GKE Standard – A4 und A3 Ultra)

A4 und A3 Ultra

Autopilot

Standard

A4X

Daten und Speicher vorbereiten

DRANET einrichten

A4 und A3 Ultra

Autopilot

Standard

A4X

Modell und Daten vorbereiten

A4 und A3 Ultra

Autopilot

Standard

A4X

Benutzerdefinierte RayCluster-Ressource bereitstellen

A4 und A3 Ultra

Autopilot

Standard

A4X

GRPO-Job starten

A4 und A3 Ultra

A4X

Bereinigen

A4 und A3 Ultra

Autopilot

Standard

A4X

Nächste Schritte

Verstärkungslernen mit verl in GKE abstimmen und skalieren