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 erfahren Sie, wie Sie eine verteilte Trainingsumgebung für Reinforcement Learning in Google Kubernetes Engine (GKE) orchestrieren. Sie verwenden Ray und das verl-Framework (Volcano Engine Reinforcement Learning), um eine Umgebung für verteiltes Training einzurichten und ein Qwen2.5-32B-Instruct-Modell für das GSM8K-Dataset abzustimmen.

In dieser Anleitung geht es um die Trainingspipeline für die gruppenbezogene relative Richtlinienoptimierung (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 der Critic oder das Wertmodell entfernt und stattdessen eine relative gruppenbasierte Berechnung verwendet wird.

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 Effizienzsteigerung entkoppelt sind.

Diese Anleitung unterstützt die folgenden GPU-Architekturen:

GPU-Knoten auf Intel- oder AMD-Basis: Einrichten und skalieren mit NVIDIA B200- oder H200-GPUs über 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 dynamischer Ressourcenzuweisung (Dynamic Resource Allocation, DRA) von GKE 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. Beim Vortraining wird einem Modell beigebracht, was es sagen soll. Beim bestärkenden Lernen durch menschliches Feedback (Reinforcement Learning from Human Feedback, RLHF) wird ihm beigebracht, 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?

Gruppenbezogene relative Richtlinienoptimierung (Group Relative Policy Optimization, GRPO)

GRPO, ein von DeepSeek entwickelter Algorithmus, bietet eine speichereffiziente Alternative zu 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
Cloud Storage FUSE verwenden, um einen Cloud Storage-Bucket auf allen Knoten bereitzustellen
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 einfach 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

Google Cloud Projekt erstellen oder auswählen

Erforderliche Rollen zum Auswählen oder Erstellen eines Projekts

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 „Project Creator“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. 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 Ihren Google Cloud Projektnamen.

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

Aktivieren Sie die erforderlichen APIs, falls noch nicht geschehen:

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

Google Cloud Projekt erstellen oder auswählen

Erforderliche Rollen zum Auswählen oder Erstellen eines Projekts

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 „Project Creator“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. 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 Ihren Google Cloud Projektnamen.

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

Aktivieren Sie die erforderlichen APIs, falls noch nicht geschehen:

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, roles/iam.serviceAccountUser
```
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 CPU_MACHINE_TYPE="YOUR_CPU_MACHINE_TYPE"
export RESERVATION="YOUR_RESERVATION_NAME"
export HF_TOKEN="YOUR_HF_TOKEN"

export GVNIC_NETWORK_PREFIX="YOUR_GVNIC_NAME"
export RDMA_NETWORK_PREFIX="YOUR_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 (GB200-Superchips) 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_CPU_MACHINE_TYPE: Der Compute Engine-Maschinentyp für den CPU-Standardknotenpool. Verwenden Sie einen highmem-Maschinentyp mit mindestens 16 vCPUs, der in Ihrer Clusterzone unterstützt wird, z. B. n4-highmem-16 oder n2d-highmem-16.
YOUR_RESERVATION_NAME: Der Name Ihrer Kapazitätsreservierung.
YOUR_HF_TOKEN: Ihr Hugging Face-Token.
Verwenden Sie die folgenden Variablen, wenn Sie Ihre Umgebung in GKE-Standardclustern einrichten:
- YOUR_GVNIC_NAME (nur A4 oder A3 Ultra): Das Präfix für den gVNIC-Netzwerknamen. Sie können ein beliebiges Präfix verwenden.
- YOUR_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 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 der Knotenpool das auto-Beschleunigernetzwerkprofil verwendet. Das Cluster Toolkit-Blueprint aktiviert dieses Profil mit dem Flag enable_dranet:true.

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=${CPU_MACHINE_TYPE} \
    --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. Diese Knotenpools verwenden Ihre Reservierung, 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}"
  --async
  --format="value(name)"
)

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

if ! OPERATION_ID="$("${CMD[@]}")" || [[ -z "${OPERATION_ID}" ]]; then
  echo "Error: Failed to initiate nodepool creation."
  exit 1
fi

# Wait for nodepool creation to complete
if [[ "${NODEPOOL_TIMEOUT:-YOUR_NODEPOOL_TIMEOUT}" == "YOUR_NODEPOOL_TIMEOUT" ]]; then
  NODEPOOL_TIMEOUT="3600"
  echo "Debug: NODEPOOL_TIMEOUT is not set to a custom value, using default: ${NODEPOOL_TIMEOUT}"
fi
echo "Waiting for nodepool ${OPERATION_ID} to be created..."
if ! timeout "${NODEPOOL_TIMEOUT}" gcloud container operations wait "${OPERATION_ID}" --location="${CONTROL_PLANE_REGION}" --project="${PROJECT_ID}"; then
  echo "Error: Nodepool creation timed out or failed after ${NODEPOOL_TIMEOUT} seconds."

  # Describe the operation to get more details
  gcloud container operations describe "${OPERATION_ID}" \
    --location="${CONTROL_PLANE_REGION}" \
    --project="${PROJECT_ID}"
  exit 1
fi
echo "Nodepool creation completed successfully."

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 auch manuell erstellen. Folgen Sie dazu der Anleitung zum Erstellen eines GKE-Cluster-Clusters.
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 (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

Erstellen Sie das ComputeClass-Manifest:

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

Sehen Sie sich das data-prep-job.yaml-Manifest an, mit dem der Job zur Datenaufbereitung konfiguriert wird:

apiVersion: batch/v1
kind: Job
metadata:
  name: data-prep-job
  namespace: ${NAMESPACE}
spec:
  template:
    metadata:
      annotations:
        gke-gcsfuse/volumes: "true"
        gke-gcsfuse/cpu-limit: "4"
        gke-gcsfuse/memory-limit: "8Gi"
        gke-gcsfuse/ephemeral-storage-limit: "50Gi"
    spec:
      serviceAccountName: ${KSA_NAME}
      restartPolicy: OnFailure
      nodeSelector:
        cloud.google.com/compute-class: Performance
        cloud.google.com/machine-family: c3
      containers:
      - name: prep-data
        image: verlai/verl:vllm011.latest
        resources:
          requests:
            cpu: "8"
            memory: "16Gi"
            ephemeral-storage: "50Gi"
          limits:
            cpu: "8"
            memory: "16Gi"
            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 --depth 1 --branch v0.6.1 https://github.com/volcengine/verl.git /data/verl

            echo "Installing verl on GCS to generate metadata..."
            pip3 install --no-deps -e /data/verl
          else
            echo "verl already exists in /data/verl"
          fi

          # Clone verl locally for fast installation
          echo "Cloning verl locally..."
          git clone --depth 1 --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 sequentially to support GCS FUSE direct streaming writes
          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

Hinweis:Wenn Sie in Autopilot cloud.google.com/compute-class: Performance ohne Angabe einer Maschinenserie angeben, wird standardmäßig die C4-Maschinenserie verwendet. Wenn in Ihrer Region kein C4-Kontingent verfügbar ist, verbleibt der Pod möglicherweise im Status Pending. Dieses Manifest gibt cloud.google.com/machine-family: c3 an. Sie können diesen Wert in data-prep-job.yaml in eine andere unterstützte Maschinenreihe (z. B. c2 oder c4) ändern, je nach regionaler Verfügbarkeit und Kontingent Ihres Projekts.

Starten Sie den Job:

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

Prüfen Sie den Pod-Status:
```
watch kubectl get pods -n ${NAMESPACE}
```
Sobald der data-prep-job-Pod den Status Running erreicht hat, drücken Sie Strg+C, um die Wiedergabe zu beenden.
Job überwachen:
```
kubectl logs -n ${NAMESPACE} -l job-name=data-prep-job -f
```
Der Befehl kubectl logs gibt erst dann eine Ausgabe zurück, wenn der Pod den Status Running erreicht hat.

Standard

Sehen Sie sich das data-prep-job.yaml-Manifest an, mit dem der Job zur Datenvorbereitung konfiguriert wird:

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

Job starten:

envsubst < 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 des 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 "Installing GIB plugins..."
              curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | gpg --dearmor -o /etc/apt/trusted.gpg.d/cloud.google.gpg
              echo 'deb https://packages.cloud.google.com/apt gpudirect-gib-apt main' | tee /etc/apt/sources.list.d/nccl-gib.list
              apt-get update && apt-get install -y nccl-gib-plugins

              echo "Local install skipped (handled by data prep)"
          volumeMounts:
          - name: training-bucket-vol
            mountPath: /data
          - name: gib
            mountPath: /usr/local/gib
        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:/usr/local/gib/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: gib
            mountPath: /usr/local/gib
            readOnly: true
          - name: shared-memory
            mountPath: /dev/shm
          - name: ray-tmp-storage
            mountPath: /tmp
          - name: training-bucket-vol
            mountPath: /data
        volumes:
        - name: gib
          emptyDir: {}
        - 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 -n "${NAMESPACE}" -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 zugehörigen 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 bestärkendes Lernen:

A4 und A3 Ultra

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

Autopilot

Ray Client einrichten:

if [ ! -d "env" ]; then
  python3 -m venv env
else
  echo "Found virtual environment env, not recreating"
fi

source env/bin/activate
pip3 install --upgrade pip
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. Der Prozess wird im Hintergrund ausgeführt, sodass Sie weiterhin Befehle in derselben Terminalsitzung ausführen können.

echo "Starting auto-restarting port-forwarding to ${SVC_NAME} on port 8265..."
run_port_forward() {
    while true; do
        kubectl port-forward svc/"${SVC_NAME}" 8265:8265 -n "${NAMESPACE}" >/dev/null 2>&1 || true
        sleep 1
    done
}
run_port_forward &
PF_LOOP_PID=$!

Verwenden Sie den Befehl kill ${PF_LOOP_PID}, um die Portweiterleitungsschleife zu beenden.

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

py_modules: ["."]
working_dir: "."
excludes:
  - ".git"
  - "env"
  - "venv"
  - ".venv"
  - "__pycache__"
  - "*.pyc"
  - ".cache"
  - "*.log"
  - "*.tmp"
  - "build"
  - "dist"
env_vars:
  PYTHONPATH: "/data/verl"
  LD_LIBRARY_PATH: "/usr/local/nvidia/lib64:/usr/local/gib/lib64"
  NCCL_DEBUG: "INFO"
  NCCL_ENV_PLUGIN: "gcp"
  NCCL_CONF_FILE: "/usr/local/gib/configs/nccl.a4.conf"
  NCCL_IB_GID_INDEX: "3"
  NCCL_NVLS_ENABLE: "0"
  NCCL_TUNER_CONFIG_PATH: "/usr/local/gib/configs"
  NUM_WORKERS: "2"
  CPUS_PER_WORKER: "192"
  GPUS_PER_WORKER: "8"
  HF_HOME: "/data/huggingface_cache"
  GLOO_SOCKET_IFNAME: "eth0"

Wenn Sie H200-GPUs verwenden, ändern Sie den Wert der Umgebungsvariable NCCL_CONF_FILE in /usr/local/gib/configs/nccl.a3u.conf.

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

Senden Sie den Job mit dem Befehl ray job submit:

SUBMIT_OUT=$(ray job submit \
  --address "http://localhost:8265" \
  --no-wait \
  --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=16 \
      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.total_training_steps=10 \
      trainer.default_local_dir=/data/verl/checkpoints \
      algorithm.adv_estimator=grpo \
      actor_rollout_ref.rollout.n=8 \
      actor_rollout_ref.actor.use_torch_compile=False \
      actor_rollout_ref.actor.fsdp_config.use_torch_compile=False \
      actor_rollout_ref.ref.use_torch_compile=False \
      actor_rollout_ref.ref.fsdp_config.use_torch_compile=False \
      trainer.total_epochs=1")
echo "${SUBMIT_OUT}"
JOB_ID=$(echo "${SUBMIT_OUT}" | grep "submitted successfully" | awk -F"'" '{print $2}' || true)

Behalten Sie die Logs des Trainingsjobs im Blick und achten Sie darauf, dass der critic/score/mean-Messwert steigt. Das deutet darauf hin, dass das Modell lernt:
- Ray-Dashboard:
  1. Öffnen Sie http://localhost:8265 in Ihrem Browser. Wenn Sie Cloud Shell verwenden, klicken Sie auf Webvorschau, wählen Sie Port ändern aus und geben Sie 8265 ein.
  2. Rufen Sie den Tab Jobs auf.
  3. Klicken Sie auf Ihre Job-ID.
  4. Filtern Sie die Logs nach dem Keyword critic, um critic/score/mean zu prüfen.
- Terminal: Da der Job asynchron mit dem Flag --no-wait gesendet wird, können Sie Joblogs im Terminal streamen, indem Sie den folgenden Befehl ausführen:
```
ray job logs "${JOB_ID}" --address "http://localhost:8265" --follow
```
Prüfen Sie nach Abschluss des Trainings, ob die Modellprüfpunkte in Ihrem Cloud Storage-Bucket gespeichert wurden. Listen Sie dazu den Verzeichnisinhalt auf:
```
gcloud storage ls "gs://${GS_BUCKET}/verl/checkpoints/"
```
Alternativ können Sie die Prüfpunkte in der Google Cloud Console ansehen. Rufen Sie dazu Cloud Storage > Buckets auf, wählen Sie YOUR_GCS_BUCKET aus und öffnen Sie den Ordner verl/checkpoints.

Standard

Ray Client einrichten:

if [ ! -d "env" ]; then
  echo "Creating local virtual environment for Ray client..."
  python3 -m venv env
else
  echo "Found virtual environment env, not recreating"
fi
source env/bin/activate
pip3 install --upgrade pip
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. Der Prozess wird im Hintergrund ausgeführt, sodass Sie weiterhin Befehle in derselben Terminalsitzung ausführen können.
```
echo "Starting port-forwarding to ${SVC_NAME} on port 8265..."
kubectl port-forward svc/"${SVC_NAME}" 8265:8265 -n "${NAMESPACE}" &
PF_PID=$!
```
Verwenden Sie den Befehl kill ${PF_PID}, um die Portweiterleitungsschleife zu beenden.

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

working_dir: "."
excludes:
  - ".git"
  - "env"
  - ".cache"
  - ".zip"
  - ".log"
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"

Wenn Sie H200-GPUs verwenden, ändern Sie den Wert der Umgebungsvariable 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:

ray job submit \
--address "http://localhost:8265" \
--runtime-env runtime-env-local.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=8 \
    actor_rollout_ref.rollout.name=vllm \
    actor_rollout_ref.rollout.log_prob_micro_batch_size_per_gpu=2 \
    actor_rollout_ref.rollout.tensor_model_parallel_size=8 \
    actor_rollout_ref.rollout.gpu_memory_utilization=0.5 \
    actor_rollout_ref.ref.log_prob_micro_batch_size_per_gpu=2 \
    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 des Trainingsjobs im Blick und achten Sie darauf, dass der critic/score/mean-Messwert steigt. Das deutet darauf hin, dass das Modell lernt:
- Ray-Dashboard:
  1. Öffnen Sie http://localhost:8265 in Ihrem Browser. Wenn Sie Cloud Shell verwenden, klicken Sie auf Webvorschau, wählen Sie Port ändern aus und geben Sie 8265 ein.
  2. Rufen Sie den Tab Jobs auf.
  3. Klicken Sie auf Ihre Job-ID.
  4. Filtern Sie die Logs nach dem Keyword critic, um den Messwert critic/score/mean zu prüfen.
- Konsolenausgabe: Da der Job asynchron mit dem Flag --no-wait gesendet wird, können Sie die Joblogs in Ihrem Terminal streamen, indem Sie den folgenden Befehl ausführen:
```
ray job logs "${JOB_ID}" --address "http://localhost:8265" --follow
```
Prüfen Sie nach Abschluss des Trainings, ob die Modellprüfpunkte in Ihrem Cloud Storage-Bucket gespeichert wurden. Listen Sie dazu den Verzeichnisinhalt auf:
```
gcloud storage ls "gs://${GS_BUCKET}/verl/checkpoints/"
```
Alternativ können Sie die Prüfpunkte in der Google Cloud Console ansehen. Rufen Sie dazu Cloud Storage > Buckets auf, wählen Sie YOUR_GCS_BUCKET aus und öffnen Sie den Ordner 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 Head-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'

Joblogs ü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

Wenn die Portweiterleitungsschleife weiterhin in Ihrer Hintergrundsitzung ausgeführt wird, beenden Sie sie:
```
kill ${PF_LOOP_PID}
```

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 2>/dev/null || true
kubectl delete -f "computeclass-dranet.yaml" --ignore-not-found=true 2>/dev/null || true

Löschen Sie den Cloud Storage-Bucket:

gcloud storage rm -r "gs://${GS_BUCKET}" --project="${PROJECT_ID:-$(gcloud config get project)}" --quiet || true

Löschen Sie den GKE-Cluster:

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

Standard

Wenn die Portweiterleitungsschleife immer noch in Ihrer Hintergrundsitzung ausgeführt wird, beenden Sie sie:
```
kill ${PF_PID}
```

Ray-Cluster löschen:

envsubst < "ray-cluster-standard.yaml" | kubectl delete --timeout=30s -f - --ignore-not-found=true || true

Löschen Sie Cloud Storage FUSE:

envsubst < "gcsfuse-storage.yaml" | kubectl delete --timeout=30s -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:

# Function to safely delete all firewall rules for a given network
delete_network_firewalls() {
  local NET_NAME=$1
  echo "Deleting all firewall rules associated with network ${NET_NAME}..."
  for rule in $(gcloud compute firewall-rules list --filter="network:${NET_NAME}" --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
}

# Delete Firewalls for both networks
delete_network_firewalls "${RDMA_NETWORK_PREFIX}-net"
delete_network_firewalls "${GVNIC_NETWORK_PREFIX}-net"

# Delete RDMA subnets
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
    echo "Deleting subnet ${RDMA_NETWORK_PREFIX}-sub-$N..."
    gcloud compute networks subnets delete ${RDMA_NETWORK_PREFIX}-sub-$N --region=${CONTROL_PLANE_REGION} --project=${PROJECT_ID} --quiet || true
  fi
done

# 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

# Function to delete VPC Network with retry and firewall re-purge
delete_vpc_network_with_retry() {
  local NET_NAME=$1
  if gcloud compute networks describe ${NET_NAME} --project=${PROJECT_ID} >/dev/null 2>&1; then
    echo "Deleting network ${NET_NAME}..."
    for attempt in {1..6}; do
      delete_network_firewalls "${NET_NAME}"
      if gcloud compute networks delete ${NET_NAME} --project=${PROJECT_ID} --quiet; then
        echo "Successfully deleted network ${NET_NAME}"
        break
      fi
      echo "Failed to delete network ${NET_NAME} on attempt ${attempt}. Retrying in 10s..."
      sleep 10
    done
  fi
}

# Delete Networks safely with retry
delete_vpc_network_with_retry "${RDMA_NETWORK_PREFIX}-net"
delete_vpc_network_with_retry "${GVNIC_NETWORK_PREFIX}-net"

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)

Gruppenbezogene relative 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

Autopilot

Standard

A4X

Bereinigen

A4 und A3 Ultra

Autopilot

Standard

A4X

Nächste Schritte

Verstärkungslernen mit verl in GKE abstimmen und skalieren