Ottimizza e scala l'apprendimento per rinforzo con Vertex AI su GKE

Autopilot Standard

Questo tutorial mostra come orchestrare un ambiente di addestramento distribuito per il reinforcement learning su Google Kubernetes Engine (GKE). Utilizzi Ray e il framework verl (Volcano Engine Reinforcement Learning) per configurare un ambiente di addestramento distribuito per ottimizzare un modello Qwen2.5-32B-Instruct sul set di dati GSM8K.

Questo tutorial si concentra sulla pipeline di addestramento Group Relative Policy Optimization (GRPO) su GKE con Ray e verl. GRPO è un algoritmo di apprendimento per rinforzo progettato per migliorare la capacità di ragionamento di un modello. Questo algoritmo efficiente in termini di memoria semplifica il processo di reinforcement learning (RL) eliminando il Critic, o modello di valore, e utilizzando invece un calcolo relativo basato sul gruppo.

Questo tutorial è un buon punto di partenza se devi configurare un ambiente di addestramento distribuito in cui dati, pesi del modello e motore di addestramento sono disaccoppiati per efficienza.

Questo tutorial supporta le seguenti architetture GPU:

• Nodi GPU basati su Intel o AMD: configura e scala utilizzando le GPU NVIDIA B200 o H200, utilizzando l'allocazione dinamica delle risorse (DRA) di GKE per il percorso Autopilot.
• Nodi A4X (GB200) basati su Arm: configura ed esegui lo scale utilizzando i superchip NVIDIA GB200 Grace Blackwell, utilizzando l'allocazione dinamica delle risorse (DRA) di GKE e NVLink multimodale (IMEX).

Sfondo

Le sezioni seguenti forniscono una breve panoramica dei concetti utilizzati in questo tutorial.

Apprendimento per rinforzo (RL)

L'RL insegna ai modelli attraverso l'esperienza, l'esplorazione e il feedback, anziché l'imitazione statica. Anche se il pre-addestramento insegna a un modello cosa dire, l'apprendimento per rinforzo con feedback umano (RLHF) gli insegna a essere utile, sicuro e logico. L'RL funge da ponte tra un modello di base e un modello sottoposto a fine-tuning per un caso d'uso specializzato.

Per saperne di più, consulta Che cos'è l'apprendimento per rinforzo?

Ottimizzazione delle policy relative al gruppo (GRPO)

GRPO, un algoritmo reso popolare da DeepSeek, offre un'alternativa efficiente in termini di memoria all'ottimizzazione delle norme prossimali (PPO) per l'allineamento degli LLM rimuovendo il modello Critic. Anziché una rete Critic, GRPO genera un gruppo di risposte per lo stesso prompt e utilizza la media dei reward di quel gruppo come baseline.

Per saperne di più, consulta GRPO.

Volcano Engine Reinforcement Learning (verl)

verl è un framework ad alte prestazioni progettato per gestire i complessi pattern di memoria e di calcolo dell'RL basato su LLM.

Per saperne di più, consulta verl.

Obiettivi

Questo tutorial mostra come configurare l'apprendimento per rinforzo su GKE con verl, completando i seguenti passaggi:

1. Configura un cluster GKE con A4X (superchip GB200), A4 (GPU B200) o A3 Ultra (GPU H200).
2. Configura KubeRay per gestire un cluster Ray distribuito.
3. Utilizza Cloud Storage FUSE per montare un bucket Cloud Storage su tutti i nodi.
4. Esegui un job di addestramento GRPO utilizzando verl per allineare il modello Qwen2.5-32B-Instruct al set di dati GSM8K.

Prima di iniziare

• Questo tutorial utilizza Cloud Shell, che include Google Cloud CLI e kubectl preinstallati. Se non utilizzi Cloud Shell, installa e inizializza Google Cloud CLI e installa kubectl.

Accedi al tuo account Google Cloud . Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei carichi di lavoro.

Installa Google Cloud CLI.

Nota: se hai già installato gcloud CLI, assicurati di avere l'ultima versione eseguendo gcloud components update.

Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

Per inizializzare gcloud CLI, esegui questo comando:

gcloud init

Crea o seleziona un Google Cloud progetto.

Ruoli richiesti per selezionare o creare un progetto

• Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per il quale ti è stato concesso un ruolo.
• Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.

Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno già esistente. Una volta completata questa procedura, puoi eliminare il progetto e tutte le relative risorse.

• Crea un progetto Google Cloud :

  gcloud projects create PROJECT_ID

  Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.

• Seleziona il progetto Google Cloud che hai creato:

  gcloud config set project PROJECT_ID

  Sostituisci PROJECT_ID con il nome del progetto Google Cloud .

Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .

Abilita le API richieste, se non sono già abilitate:

Ruoli richiesti per abilitare le API

Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente disponi già di questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

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

Installa Google Cloud CLI.

Nota: se hai già installato gcloud CLI, assicurati di avere l'ultima versione eseguendo gcloud components update.

Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

Per inizializzare gcloud CLI, esegui questo comando:

gcloud init

Crea o seleziona un Google Cloud progetto.

Ruoli richiesti per selezionare o creare un progetto

• Seleziona un progetto: la selezione di un progetto non richiede un ruolo IAM specifico. Puoi selezionare qualsiasi progetto per il quale ti è stato concesso un ruolo.
• Crea un progetto: per creare un progetto, devi disporre del ruolo Autore progetto (roles/resourcemanager.projectCreator), che contiene l'autorizzazione resourcemanager.projects.create. Scopri come concedere i ruoli.

Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno già esistente. Una volta completata questa procedura, puoi eliminare il progetto e tutte le relative risorse.

• Crea un progetto Google Cloud :

  gcloud projects create PROJECT_ID

  Sostituisci PROJECT_ID con un nome per il progetto Google Cloud che stai creando.

• Seleziona il progetto Google Cloud che hai creato:

  gcloud config set project PROJECT_ID

  Sostituisci PROJECT_ID con il nome del progetto Google Cloud .

Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud .

Abilita le API richieste, se non sono già abilitate:

Ruoli richiesti per abilitare le API

Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente disponi già di questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.

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

• Concedi i ruoli al tuo account utente. Esegui il seguente comando una volta per ciascuno dei seguenti ruoli IAM: 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

  Sostituisci quanto segue:

  • PROJECT_ID: il tuo ID progetto.
  • USER_IDENTIFIER: l'identificatore del tuo account utente. Ad esempio: [e-mail].
  • ROLE: il ruolo IAM che concedi al tuo account utente.

• Crea un account Hugging Face, se non ne hai già uno.
• Assicurati di avere un token Hugging Face.
• Assicurati che il tuo progetto disponga di una quota sufficiente per A4X (superchip GB200), A4 (GPU B200) o A3 Ultra (GPU H200). Per scoprire di più, consulta Pianificare la quota di GPU e Quota di GPU.
• Assicurati di avere una prenotazione di capacità attiva per il tipo di macchina GPU. Per ulteriori informazioni, vedi Riservare capacità tramite il team dedicato all'account.
• Per la configurazione di A4X (GB200), assicurati di aver installato Helm.

prepara l'ambiente

In questo tutorial utilizzi Cloud Shell.

1. Vai alla consoleGoogle Cloud .

2. Nella parte superiore della finestra della console Google Cloud , fai clic sul pulsante Attiva Cloud Shell.

3. Imposta le variabili di ambiente:

   A4 e 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
   

   Sostituisci i seguenti valori:

   • YOUR_REGION: la regione di Compute Engine per il control plane del cluster GKE.
   • YOUR_ZONE: la zona in cui sono prenotati i nodi. Per saperne di più, consulta Disponibilità delle GPU.
   • YOUR_CLUSTER_NAME: il nome del tuo cluster GKE. Questo nome deve contenere al massimo 40 caratteri ed essere composto da caratteri alfanumerici minuscoli e trattini.
   • YOUR_KSA_NAME: il nome del tuo account di servizio Kubernetes.
   • YOUR_GCS_BUCKET: il nome di base del bucket Cloud Storage. Non è necessario specificare il prefisso gs://.
   • YOUR_GPU_TYPE: l'acceleratore che hai prenotato nella prenotazione di capacità di Compute Engine. Deve essere uno dei seguenti valori:
     • nvidia-gb200: A4X (GB200 Superchips)
     • nvidia-b200: A4 (GPU B200)
     • nvidia-h200-141gb: A3 Ultra (GPU H200)
   • YOUR_MACHINE_TYPE: il tipo di macchina da utilizzare:
     • Per A4X (superchip GB200), utilizza a4x-highgpu-4g.
     • Per A4 (GPU B200), utilizza a4-highgpu-8g o versioni successive.
     • Per A3 Ultra (GPU H200), utilizza a3-ultragpu-8g o versioni successive.
   • YOUR_CPU_MACHINE_TYPE: il tipo di macchina Compute Engine per il pool di nodi predefinito della CPU. Utilizza un tipo di macchina highmem con almeno 16 vCPU supportate nella zona del cluster, ad esempio n4-highmem-16 o n2d-highmem-16.
   • YOUR_RESERVATION_NAME: il nome della prenotazione di capacità.
   • YOUR_HF_TOKEN: il tuo token Hugging Face.
   • Utilizza le seguenti variabili durante la configurazione dell'ambiente nei cluster GKE Standard:
     • YOUR_GVNIC_NAME (solo A4 o A3 Ultra): il prefisso per il nome della rete gVNIC. Puoi utilizzare qualsiasi prefisso.
     • YOUR_RDMA_NAME (solo A4 o A3 Ultra): il prefisso per la rete RDMA (Remote Direct Memory Access). Puoi utilizzare qualsiasi prefisso.

4. Clona il repository di esempio:

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

   Nel resto del tutorial, cerca nella tua clonazione del repository di esempio i file specifici che devi esaminare o applicare.

5. Vai alla directory di lavoro per la modalità GKE scelta:

   A4 e A3 Ultra

   Autopilot

   cd AIHypercomputerSamples/gpu/tuning/verl_rl_autopilot

   Standard

   cd AIHypercomputerSamples/gpu/tuning/verl_rl_standard

   A4X

   Non è necessario modificare la directory. Puoi passare direttamente alla sezione successiva.

Configurazione dell'infrastruttura

In questa sezione, creerai reti VPC standard e il cluster GKE.

Crea una rete e delle subnet RDMA (solo GKE Standard - A4 e A3 Ultra)

A4 e A3 Ultra

Autopilot

Questa sezione è obbligatoria solo per le GPU GKE Standard A4 e A3 Ultra.

Se utilizzi Autopilot, salta questa sezione e vai direttamente a Crea un cluster GKE. GKE esegue automaticamente il provisioning delle reti VPC e delle subnet necessarie e utilizza GKE Managed DRANET per allocare queste risorse ai tuoi pod. Non è necessario creare manualmente un'infrastruttura di rete.

Standard

1. Crea una rete VPC per l'interfaccia gVNIC:

   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}

2. Crea una rete VPC per RDMA:

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

3. Crea le 8 subnet RDMA per le 8 GPU:

   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

Questa sezione è obbligatoria solo per le GPU GKE Standard A4 e A3 Ultra.

Se utilizzi GPU A4X (GB200), salta questa sezione e vai direttamente a Crea un cluster GKE. Per le GPU A4X (GB200) o Autopilot, GKE crea automaticamente le reti quando il pool di nodi utilizza il profilo di rete dell'acceleratore auto. Il progetto base di Cluster Toolkit attiva questo profilo utilizzando il flag enable_dranet:true.

Crea un cluster GKE

Crea un cluster GKE corrispondente alla tua architettura GPU:

A4 e A3 Ultra

Seleziona la modalità cluster GKE che vuoi utilizzare:

Autopilot

1. Crea un cluster Autopilot:

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

2. Recupera le credenziali per il tuo cluster:

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

Standard

1. Crea un cluster Standard:

   gcloud container clusters create ${CLUSTER_NAME} \
       --location=${CONTROL_PLANE_REGION} \
       --node-locations=${NODE_ZONE} \
       --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}

2. Recupera le credenziali per il tuo cluster:

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

3. Crea il pool di nodi GPU. Questi node pool utilizzano la prenotazione per garantire la disponibilità. Inizia con due nodi:

   RESERVATION_ARGS=("--reservation-affinity=none")
   if [ -n "${RESERVATION:-}" ]; then
     RESERVATION_ARGS=("--reservation-affinity=specific" "--reservation=${RESERVATION}")
   fi
   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" \
       --num-nodes=2 \
       "${RESERVATION_ARGS[@]}" \
       --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}"

4. Installa il programma di installazione NCCL RDMA utilizzato per i cluster Standard:

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

A4X

1. Crea un cluster GKE e pool di nodi utilizzando il blueprint Cluster Toolkit gke-a4x. Il progetto esegue il provisioning del cluster GKE, incluso il pool di nodi A4X associato alla tua prenotazione, le reti di acceleratori (un gVNIC aggiuntivo più quattro rail RDMA) e il driver DRANET gestito che espone le NIC CX-7 come dispositivi DRA.

   Utilizza le istruzioni di deployment del blueprint per configurare i parametri (ad esempio PROJECT_ID, CONTROL_PLANE_REGION, NODE_ZONE, prenotazione e NUM_GPU_NODES), quindi esegui il deployment del cluster. In alternativa, puoi seguire la guida alla creazione di cluster GKE A4X per creare un cluster manualmente.

   1. Recupera le credenziali per il tuo cluster:

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

2. Verifica che il cluster esponga le NIC RDMA tramite DRA:

   kubectl get deviceclasses
   

   L'output deve includere mrdma.google.com.

3. Verifica che i nodi A4X siano presenti:

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

4. Installa il plug-in NCCL gIB (variante A4X):

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

5. Installa il driver NVIDIA DRA, che fornisce canali ComputeDomain (IMEX) per NVLink multinodo:

   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
   

6. Installa l'operatore KubeRay, con ambito limitato allo spazio dei nomi del carico di lavoro:

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

Configura le mappature di rete (solo GKE Standard - A4 e A3 Ultra)

A4 e A3 Ultra

Autopilot

Questo passaggio è obbligatorio per le configurazioni GPU GKE Standard (solo A4 e A3 Ultra). Se utilizzi A4X (GB200), GKE gestisce automaticamente le interfacce di rete, quindi salta questa sezione.

Standard

1. Esamina il manifest network-mapping.yaml:

   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

2. Applica il manifest:

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

A4X

Questo passaggio è obbligatorio per le configurazioni GPU GKE Standard (solo A4 e A3 Ultra). Se utilizzi A4X (GB200), GKE gestisce le interfacce di rete automaticamente, quindi salta questa sezione.

Prepara dati e spazio di archiviazione

Configura le risorse Cloud Storage e Kubernetes:

1. Crea un bucket Cloud Storage:

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

2. Crea un service account Kubernetes (KSA) e associalo al 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"

3. Crea il secret per Hugging Face:

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

4. Controlla il manifest gcsfuse-storage.yaml:

   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

5. Applica il manifest:

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

Configurare DRANET

Configura DRANET:

A4 e A3 Ultra

Autopilot

1. Crea il manifest ComputeClass:

   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

2. Applica sia il manifest computeclass-dranet.yaml (creato nel passaggio precedente) sia il manifest resourceclaim-dranet.yaml (incluso nel repository di esempio):

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

Standard

Non è richiesta alcuna configurazione DRANET. Puoi procedere direttamente alla sezione successiva.

A4X

DRANET è impostato da Cluster Toolkit. Puoi procedere direttamente alla sezione successiva.

Prepara il modello e i dati

Completa il bucket Cloud Storage con i pesi e i set di dati del modello. Puoi eseguire questi comandi localmente o su un pod GKE per compilare il bucket:

A4 e A3 Ultra

Autopilot

1. Esamina il manifest data-prep-job.yaml, che configura il job di preparazione dei dati:

   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

   Nota: in Autopilot, se specifichi cloud.google.com/compute-class: Performance senza una serie di macchine, per impostazione predefinita viene utilizzata la serie di macchine C4. Se non hai una quota C4 nella tua regione, il pod potrebbe rimanere nello stato Pending. Questo manifest specifica cloud.google.com/machine-family: c3. Puoi modificare questo valore in data-prep-job.yaml in un'altra serie di macchine supportata (ad esempio c2 o c4) in base alla disponibilità regionale e alla quota del tuo progetto.

2. Avvia il job:

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

3. Controlla lo stato del pod:

   watch kubectl get pods -n ${NAMESPACE}

   Dopo che il pod data-prep-job ha raggiunto lo stato Running, premi Ctrl+C per interrompere il monitoraggio.

4. Monitora il job:

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

   Il comando kubectl logs restituisce un output minimo o nullo finché il pod non raggiunge lo stato Running.

Standard

1. Esamina il manifest data-prep-job.yaml, che configura il job di preparazione dei dati:

   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 --depth 1 --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 --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
             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

2. Avvia il job:

   envsubst < data-prep-job.yaml | kubectl apply -f -
   echo "Waiting for data-prep-job Pod to be created and pull image (this takes ~5 minutes)..."
   until [ -n "$(kubectl get pods -l job-name=data-prep-job -n "${NAMESPACE}" --no-headers 2>/dev/null)" ]; do
     sleep 2
   done
   kubectl wait --for=condition=ready pod -l job-name=data-prep-job -n "${NAMESPACE}" --timeout=600s

3. Monitora il job:

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

A4X

1. Clona il repository verl, prepara l'ambiente virtuale ed elabora il set di dati GSM8K:

   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
   

2. Scarica il modello Qwen2.5-32B-Instruct utilizzando Hugging Face CLI (questo download richiede circa 66 GB di spazio su disco):

   hf download Qwen/Qwen2.5-32B-Instruct --local-dir Qwen2.5-32B-Instruct
   

3. Carica il modello, i dati e il codice di verifica nel bucket Cloud Storage:

   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/
   

Esegui il deployment della risorsa personalizzata RayCluster

Esegui il deployment di una risorsa personalizzata RayCluster, composta da un pod head di sistema e da più pod worker supportati da GPU.

A4 e A3 Ultra

Seleziona la modalità cluster GKE che hai utilizzato per creare il cluster:

Autopilot

1. Ispeziona il workload RayCluster:

   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

2. Applica il RayCluster:

   envsubst < "ray-cluster-auto-dranet.yaml" | kubectl apply -n "${NAMESPACE}" -f -

Standard

1. Ispeziona il workload RayCluster:

   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:
           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

2. Applica il RayCluster:

   envsubst < "ray-cluster-standard.yaml" | kubectl apply -f -
   echo "Waiting for Ray head and GPU worker Pods to pull images and become Ready (this takes ~2–5 minutes)..."
   until [ -n "$(kubectl get pods -l ray.io/cluster=b200-ray-cluster -n "${NAMESPACE}" --no-headers 2>/dev/null)" ]; do
     sleep 2
   done
   kubectl wait --for=condition=ready pod -l ray.io/cluster=b200-ray-cluster -n "${NAMESPACE}" --timeout=1200s

A4X

1. Crea ResourceClaimTemplate RDMA e ComputeDomain NVIDIA. Ogni pod worker GPU richiede quattro NIC RDMA (tutti i rail del nodo) e un canale IMEX. Salva il seguente manifest in 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
   

2. Applica il manifest:

   kubectl apply -f compute-domain-a4x.yaml
   

3. Esegui il deployment del RayCluster. Il pod head di Ray viene eseguito su un nodo A4X senza richiedere GPU (poiché l'immagine è solo per arm64). Salva le seguenti configurazioni 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
   

4. Applica il manifest RayCluster:

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

5. Attendi finché un pod head e quattro pod worker non sono nello stato Running:

   kubectl get pods -w
   

Avvia il job GRPO

Configura e invia il job di addestramento per l'apprendimento per rinforzo:

A4 e A3 Ultra

Seleziona la modalità cluster GKE che hai utilizzato per creare il cluster:

Autopilot

1. Configura Ray Client:

   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]

2. Recupera il servizio head Ray:

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

3. Configura il port forwarding al nodo della dashboard Ray. Il processo viene eseguito in background, quindi puoi continuare a eseguire comandi nella stessa sessione del terminale.

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

   Per interrompere il ciclo di port forwarding, utilizza il comando kill ${PF_LOOP_PID}.

4. Esamina il manifest runtime-env.yaml:

   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"

   Se utilizzi GPU H200, modifica il valore della variabile di ambiente NCCL_CONF_FILE in /usr/local/gib/configs/nccl.a3u.conf.

   Questo file viene utilizzato dal client Ray. Non devi applicare questo manifest al cluster.

5. Invia il job utilizzando il comando 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)

6. Monitora i log del job di addestramento e cerca la metrica critic/score/mean in aumento, il che indica che il modello sta apprendendo:

   • Dashboard di Ray:
     1. Apri http://localhost:8265 nel browser. Se utilizzi Cloud Shell, fai clic su Anteprima web, seleziona Cambia porta e inserisci 8265.
     2. Vai alla scheda Job.
     3. Fai clic sull'ID job.
     4. Filtra i log in base alla parola chiave critic per ispezionare critic/score/mean.

   • Terminale: poiché il job viene inviato in modo asincrono con il flag --no-wait, trasmetti in streaming i log del job nel terminale eseguendo questo comando:

     ray job logs "${JOB_ID}" --address "http://localhost:8265" --follow

7. Al termine dell'addestramento, verifica che i checkpoint del modello siano stati salvati nel bucket Cloud Storage elencando i contenuti della directory:

   gcloud storage ls "gs://${GS_BUCKET}/verl/checkpoints/"

   In alternativa, visualizza i checkpoint nella console Google Cloud andando su Cloud Storage > Bucket, selezionando YOUR_GCS_BUCKET e aprendo la cartella verl/checkpoints.

Standard

1. Configura il client Ray:

   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]

2. Recupera il servizio head Ray:

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

3. Configura il port forwarding al nodo della dashboard di Ray. Il processo viene eseguito in background, quindi puoi continuare a eseguire comandi nella stessa sessione del terminale.

   echo "Starting port-forwarding loop to ${SVC_NAME} on port 8265..."
   run_port_forward() {
       while true; do
           kubectl port-forward --address 0.0.0.0 svc/"${SVC_NAME}" 8265:8265 -n "${NAMESPACE}" >/dev/null 2>&1 || true
           sleep 1
       done
   }
   run_port_forward &
   PF_PID=$!
   export RAY_ADDRESS="http://localhost:8265"
   sleep 3

   Per interrompere il ciclo di port forwarding, utilizza il comando kill ${PF_PID}.

4. Esamina il manifest runtime-env.yaml:

   working_dir: "."
   excludes:
     - ".git"
     - "env"
     - ".cache"
     - ".zip"
     - ".log"
   env_vars:
     PYTHONPATH: "/data/verl"
     LD_LIBRARY_PATH: "/usr/local/nvidia/lib64"
     NCCL_DEBUG: "WARN"
     NCCL_NVLS_ENABLE: "0"
     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"

   Se utilizzi GPU H200, modifica il valore della variabile di ambiente NCCL_TUNER_CONFIG_PATH in /usr/local/gib/configs/tuner_config_a3u.txtpb.

   Questo file viene utilizzato dal client Ray. Non è necessario applicare questo manifest al cluster.

5. Invia il job:

   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=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.total_training_steps=10 \
       trainer.default_local_dir=/data/verl/checkpoints \
       algorithm.adv_estimator=grpo \
       actor_rollout_ref.rollout.n=8 \
       trainer.total_epochs=1")
   echo "${SUBMIT_OUT}"
   JOB_ID=$(echo "${SUBMIT_OUT}" | grep "submitted successfully" | awk -F"'" '{print $2}' || true)

6. Monitora i log del job di addestramento e cerca la metrica critic/score/mean in aumento, il che indica che il modello sta apprendendo:

   • Dashboard di Ray:
     1. Apri http://localhost:8265 nel browser. Se utilizzi Cloud Shell, fai clic su Anteprima web, seleziona Cambia porta e inserisci 8265.
     2. Vai alla scheda Job.
     3. Fai clic sull'ID job.
     4. Filtra i log in base alla parola chiave critic per esaminare la metrica critic/score/mean.

   • Output della console: poiché il job viene inviato in modo asincrono con il flag --no-wait, trasmetti i log del job in streaming nel terminale eseguendo questo comando:

     ray job logs "${JOB_ID}" --address "http://localhost:8265" --follow

7. Al termine dell'addestramento, verifica che i checkpoint del modello siano stati salvati nel bucket Cloud Storage elencando i contenuti della directory:

   gcloud storage ls "gs://${GS_BUCKET}/verl/checkpoints/"

   In alternativa, visualizza i checkpoint nella console Google Cloud andando su Cloud Storage > Bucket, selezionando YOUR_GCS_BUCKET e aprendo la cartella verl/checkpoints.

A4X

1. Ottieni il nome del pod della testa di Ray:

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

2. Configura il file dell'ambiente di runtime Ray direttamente nel pod head:

   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'
   

3. Invia il job di addestramento GRPO eseguendolo sul pod di intestazione Ray:

   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'
   

4. Monitora i log del job (utilizzando l'ID univoco restituito da ray job submit):

   kubectl exec ${HEAD_POD} -c ray-head -- ray job logs <var>JOB_ID</var> --follow
   

   Sostituisci JOB_ID. Verifica che NVLink tra nodi sia attivo cercando le righe NCCL nei log contenenti via P2P/MNNVL.

Esegui la pulizia

Per evitare che ti vengano addebitati dei costi, elimina le risorse:

A4 e A3 Ultra

Autopilot

1. Se il ciclo di port forwarding è ancora in esecuzione nella sessione in background, termina:

   kill ${PF_LOOP_PID}

2. Elimina il cluster Ray:

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

3. Elimina Cloud Storage FUSE:

   kubectl delete job data-prep-job -n "${NAMESPACE:-default}" --ignore-not-found=true || true
   envsubst < "gcsfuse-storage.yaml" | kubectl delete --timeout=30s -f - --ignore-not-found=true || true

4. Elimina le risorse DRANET:

   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

5. Elimina il bucket Cloud Storage:

   gcloud storage rm -r "gs://${GS_BUCKET}" --project="${PROJECT_ID:-$(gcloud config get project)}" --quiet || {
     echo "First deletion attempt failed. Retrying in 5 seconds..."
     sleep 5
     gcloud storage rm -r "gs://${GS_BUCKET}" --project="${PROJECT_ID:-$(gcloud config get project)}" --quiet
   } || true

6. Elimina il cluster GKE:

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

Standard

1. Se il loop di port forwarding è ancora in esecuzione nella sessione in background, terminalo:

   kill ${PF_PID}

2. Elimina il cluster Ray:

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

3. Elimina Cloud Storage FUSE:

   kubectl delete job data-prep-job -n ${NAMESPACE} --ignore-not-found=true || true
   envsubst < "gcsfuse-storage.yaml" | kubectl delete --timeout=30s -f - --ignore-not-found=true || true

4. Elimina il bucket Cloud Storage:

   gcloud storage rm -r "gs://${GS_BUCKET}" --project="${PROJECT_ID}" || {
     echo "First deletion attempt failed. Retrying in 5 seconds..."
     sleep 5
     gcloud storage rm -r "gs://${GS_BUCKET}" --project="${PROJECT_ID}"
   } || true

5. Elimina il cluster GKE:

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

6. Elimina le reti e le subnet VPC:

   # 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}

Passaggi successivi

• Scopri di più su Ray su GKE
• Scopri di più sulla creazione di cluster A4X su GKE
• Esplora la documentazione di verl