GKE ve Managed Lustre ile Pekiştirmeli Öğrenmeyi Ölçeklendirme

1. Giriş

Paketlenmiş komut dosyalarını adım adım eğitim olmadan doğrudan çalıştırmayı tercih ederseniz bunları GoogleCloudPlatform/devrel-demos deposunda bulabilirsiniz.

Bu codelab'de, Google Kubernetes Engine (GKE) ve Managed Lustre kullanarak pekiştirmeli öğrenme (RL) için yüksek performanslı bir eğitim ardışık düzenini nasıl dağıtacağınızı öğreneceksiniz.

Özellikle Group Relative Policy Optimization (GRPO) gibi algoritmaları kullanan pekiştirmeli öğrenme iş yükleri, "Deneyim Oluşturma" sırasında büyük miktarda veri oluşturur ve sık sık kontrol noktası oluşturmayı gerektirir. Standart nesne depolama, bu G/Ç patlamaları sırasında darboğazlara neden olabilir ve pahalı hızlandırıcıları boşta bırakabilir.

Bu darboğazları ortadan kaldırmak ve daha yüksek eğitim işleme hızı elde etmek için paralel dosya sistemi olan Managed Lustre'ı kullanacaksınız.

Yapacaklarınız

• GPU tabanlı bir Ray kümesi için ortam değişkenlerini yapılandırın.
• XPK aracını kullanarak GKE'de Spot GPU kümesi sağlayın.
• Yönetilen Lustre örneği oluşturun.
• KubeRay kümesi dağıtın ve Lustre dosya sistemini bağlayın.
• NeMo-RL eğitim iş yükü gönderin.
• Cloud Monitoring'i kullanarak yüksek gönderim hacmi ve düşük kontrol noktası gecikmesini gözlemleyin.

İhtiyacınız olanlar

• Chrome gibi bir web tarayıcısı
• Faturalandırmanın etkin olduğu bir Google Cloud projesi.

Bu codelab'de, Spot GPU'lar ve Managed Lustre gibi üst düzey kaynaklar kullanılır. Maliyetleri düşürmek için Spot kapasitesini kullanırız ancak bu kaynaklar çalışır durumda bırakılırsa pahalı olabilir. Beklenmedik ücretlerle karşılaşmamak için laboratuvarın sonunda her zaman Temizleme adımını uygulayın.

Bu codelab, GKE ve depolama kavramlarına aşina olan ileri düzey teknik kullanıcılar, platform mühendisleri ve yapay zeka araştırmacıları içindir.

Tahmini toplam süre: 45-60 dakika artı 2 saatlik eğitim süresi

2. Başlamadan önce

Google Cloud projesi oluşturma

1. Google Cloud Console'da bir Google Cloud projesi seçin veya oluşturun.
2. Cloud projeniz için faturalandırmanın etkinleştirildiğinden emin olun.

Cloud Shell'i Başlatma

Cloud Shell, Google Cloud'da çalışan ve gerekli araçların önceden yüklendiği bir komut satırı ortamıdır.

1. Google Cloud Console'un üst kısmından Cloud Shell'i etkinleştir'i tıklayın.
2. Cloud Shell'e bağlandıktan sonra kimlik doğrulamanızı onaylayın:

   gcloud auth list
   

3. Projenizin yapılandırıldığını onaylayın:

   gcloud config get project
   

4. Projeniz beklendiği gibi ayarlanmamışsa şu şekilde ayarlayın:

   export PROJECT_ID=<YOUR_PROJECT_ID>
   gcloud config set project $PROJECT_ID
   

XPK'yı yükleme

Bu codelab'de GKE kümesini sağlama için xpk kullanılır. xpk yükleme talimatları için xpk yükleme kılavuzuna bakın.

Cloud Shell'de aşağıdaki komutla yükleyebilirsiniz:

pip install xpk

API'leri etkinleştir

Gerekli tüm API'leri etkinleştirmek için Cloud Shell'de şu komutu çalıştırın:

gcloud services enable \
  container.googleapis.com \
  lustre.googleapis.com \
  compute.googleapis.com \
  servicenetworking.googleapis.com

3. Ortam değişkenlerini yapılandırma

Bu codelab'deki komutların tutarlı olması için birkaç ortam değişkeni ayarlayın.

env.sh adlı bir dosya oluşturun ve yapılandırmanızla doldurun. Aşağıdaki şablonu kullanabilirsiniz:

# Environment Variables for the RL Demo execution
export PROJECT_ID="<YOUR_PROJECT_ID>"
export ZONE="us-east1-b"
export REGION="us-east1"
export CLUSTER_NAME="ray-a4-gpu-spot"
export NETWORK_NAME="${CLUSTER_NAME}-net-0" # Implicitly targets the VPC created by XPK
export LUSTRE_INSTANCE_ID="rl-demo-gpu-lustre"
export LUSTRE_CAPACITY="9000" # Capacity in GiB
export HF_TOKEN="<YOUR_HF_TOKEN>" # Required for downloading models
export WANDB_API_KEY="<YOUR_WANDB_API_KEY>" # Optional

# Topology defaults
export NUM_NODES="8"
export GPUS_PER_NODE="8" # Fixed for A4/B200 architecture
export DEVICE_TYPE="b200-8"

HF_TOKEN, modelleri indirmek için gereken Hugging Face kullanıcı erişim jetonunuzdur. Hugging Face Security Tokens sayfasındaki talimatları uygulayarak bir tane edinebilirsiniz.

<YOUR_PROJECT_ID> ve <YOUR_HF_TOKEN> değerlerini gerçek değerlerinizle değiştirin.

WANDB_API_KEY isteğe bağlıdır. Makine öğrenimi denemelerini izlemek ve görselleştirmek için kullanılan bir araç olan Weights & Biases için kullanılır. Hesabınız yoksa veya hesabınızı kullanmak istemiyorsanız bu alanı boş bırakabilir ya da olduğu gibi bırakabilirsiniz.

Değişkenleri mevcut oturumunuza yüklemek için dosyayı kaynaklayın:

source env.sh

4. XPK kullanarak GKE kümesi oluşturma

Bu adımda, Spot GPU'lar içeren bir GKE kümesi sağlamak için xpk kullanacaksınız.

xpk, otomatik iş yükleri için GKE kümesi oluşturmayı basitleştiren Yapay Zeka Hiper Bilgisayarı sağlama aracıdır. Cihaz türünü ve düğüm sayısını belirterek gerekli VPC, alt ağ ve düğüm havuzlarını oluşturur.

Küme oluşturma komutunu çalıştırın:

xpk cluster create \
  --num-nodes=${NUM_NODES} \
  --device-type=${DEVICE_TYPE} \
  --default-pool-cpu-machine-type="e2-standard-4" \
  --spot \
  --enable-lustre-csi-driver \
  --project=${PROJECT_ID} \
  --zone=${ZONE} \
  --cluster=${CLUSTER_NAME}

Kümenin oluşturulmasını bekleyin. Bu işlem birkaç dakika sürebilir.

RayOperator eklentisini etkinleştirme

Küme oluşturulduktan sonra KubeRay kümelerini yönetmek için RayOperator eklentisini etkinleştirin:

gcloud container clusters update ${CLUSTER_NAME} \
  --region ${REGION} \
  --project ${PROJECT_ID} \
  --update-addons=RayOperator=ENABLED

Lustre CSI sürücüsünü doğrulama

XPK, --enable-lustre-csi-driver işareti aracılığıyla Lustre CSI sürücüsünü otomatik olarak etkinleştirmelidir. Etkinleştirildiğini doğrulayın:

gcloud container clusters describe ${CLUSTER_NAME} \
  --region ${REGION} \
  --project ${PROJECT_ID} \
  --format="value(addonsConfig.lustreCsiDriverConfig.enabled)"

false döndürürse yedek etkinleştirme komutunu çalıştırın:

gcloud container clusters update ${CLUSTER_NAME} \
  --region ${REGION} \
  --project ${PROJECT_ID} \
  --update-addons=LustreCsiDriver=ENABLED

--spot kullanmak maliyetleri önemli ölçüde azaltır. Ancak Spot kapasitesi öncelikli olarak kullanılabilir. Üretim için ayrılmış veya isteğe bağlı örnekler kullanırsınız.

5. Yönetilen Lustre örneği sağlama

Bu adımda, Lustre için Yönetilen Hizmet örneği oluşturursunuz. Lustre, kontrol noktası oluşturma için yüksek gönderim hacmi sağlayan bir paralel dosya sistemidir.

Yönetilen Hizmetler İçin IP Aralığı Ayırma

Lustre, Google Yönetilen Hizmetleri ile VPC eşleme bağlantısı gerektirir. Öncelikle genel bir IP aralığı ayırın:

gcloud compute addresses create "google-managed-services-${NETWORK_NAME}" \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=24 \
    --network="${NETWORK_NAME}" \
    --project="${PROJECT_ID}"

VPC eşleme oluşturma

VPC'nizi Service Networking'e bağlayın:

gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges="google-managed-services-${NETWORK_NAME}" \
    --network="${NETWORK_NAME}" \
    --project="${PROJECT_ID}" || \
gcloud services vpc-peerings update \
    --service=servicenetworking.googleapis.com \
    --ranges="google-managed-services-${NETWORK_NAME}" \
    --network="${NETWORK_NAME}" \
    --project="${PROJECT_ID}" \
    --force

Lustre örneği oluşturma

Şimdi Lustre örneğini oluşturun. Bu komut eşzamansız olarak çalışır.

gcloud lustre instances create "${LUSTRE_INSTANCE_ID}" \
    --project="${PROJECT_ID}" \
    --location="${ZONE}" \
    --capacity-gib="${LUSTRE_CAPACITY}" \
    --per-unit-storage-throughput="1000" \
    --filesystem="lustre" \
    --network="projects/${PROJECT_ID}/global/networks/${NETWORK_NAME}" \
    --gke-support-enabled \
    --async

Lustre durumunu doğrulama

Lustre örneğinin hazır olması yaklaşık 10-15 dakika sürer. Durumu şu araçlarla kontrol edebilirsiniz:

gcloud lustre instances describe ${LUSTRE_INSTANCE_ID} \
    --project ${PROJECT_ID} \
    --location ${ZONE} \
    --format="value(state)"

Devam etmeden önce durumun ACTIVE olmasını bekleyin.

6. GKE'de Ray kümesi dağıtma

Bu adımda, GKE düğümlerinize bir KubeRay kümesi dağıtacak ve PersistentVolume (PV) ile PersistentVolumeClaim (PVC) kullanarak Lustre dosya sistemini bağlayacaksınız.

Fetch Lustre IP

Birim oluşturmadan önce Lustre örneğinizin ekleme noktası IP'sini almanız gerekir:

export LUSTRE_IP=$(gcloud lustre instances describe "${LUSTRE_INSTANCE_ID}" --project="${PROJECT_ID}" --location="${ZONE}" --format="value(mountPoint)" | cut -d'@' -f1)
echo "Lustre IP is: ${LUSTRE_IP}"

Lustre PV ve PVC oluşturma

Aşağıdaki yapılandırmayı kullanarak rl-lustre-volume.yaml adlı bir dosya oluşturun. Bu, GKE'nin Lustre örneğinize nasıl bağlandığını tanımlar.

cat << EOF > rl-lustre-volume.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
  name: rl-demo-gpu-lustre-pv
spec:
  capacity:
    storage: ${LUSTRE_CAPACITY}Gi
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  volumeMode: Filesystem
  claimRef:
    namespace: default
    name: rl-demo-gpu-lustre-pvc
  csi:
    driver: lustre.csi.storage.gke.io
    volumeHandle: ${PROJECT_ID}/${ZONE}/${LUSTRE_INSTANCE_ID}
    volumeAttributes:
      ip: ${LUSTRE_IP}
      filesystem: lustre
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: rl-demo-gpu-lustre-pvc
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: ""
  volumeName: rl-demo-gpu-lustre-pv
  resources:
    requests:
      storage: ${LUSTRE_CAPACITY}Gi
EOF

Ses yapılandırmasını uygulayın:

kubectl apply -f rl-lustre-volume.yaml

RayCluster Yapılandırması Oluşturma

ray-cluster.yaml adlı bir dosya oluşturun. Bu, nvidia-b200 hızlandırıcı türünü kullanarak ve Lustre birimini /lustre konumuna monte ederek KubeRay baş ve çalışan düğümlerini belirtir.

cat << EOF > ray-cluster.yaml
apiVersion: ray.io/v1
kind: RayCluster
metadata:
  name: ${CLUSTER_NAME}
  namespace: default
spec:
  rayVersion: '2.54.0'
  headGroupSpec:
    rayStartParams:
      dashboard-host: '0.0.0.0'
    template:
      spec:
        nodeSelector:
          cloud.google.com/gke-accelerator: nvidia-b200
        tolerations:
        - key: "nvidia.com/gpu"
          operator: "Exists"
          effect: "NoSchedule"
        containers:
        - name: ray-head
          image: nvcr.io/nvidia/nemo-rl:v0.4.0
          ports:
          - containerPort: 6379
            name: gcs-server
          - containerPort: 8265
            name: dashboard
          - containerPort: 10001
            name: client
          resources:
            limits:
              cpu: "32"
              memory: "1000Gi"
            requests:
              cpu: "8"
              memory: "64Gi"
          volumeMounts:
          - mountPath: /lustre
            name: lustre-storage
        volumes:
        - name: lustre-storage
          persistentVolumeClaim:
            claimName: rl-demo-gpu-lustre-pvc
  workerGroupSpecs:
  - groupName: gpu-worker-group
    replicas: ${NUM_NODES}
    minReplicas: ${NUM_NODES}
    maxReplicas: ${NUM_NODES}
    rayStartParams: {}
    template:
      spec:
        nodeSelector:
          cloud.google.com/gke-accelerator: nvidia-b200
        tolerations:
        - key: "nvidia.com/gpu"
          operator: "Exists"
          effect: "NoSchedule"
        containers:
        - name: ray-worker
          image: nvcr.io/nvidia/nemo-rl:v0.4.0
          resources:
            limits:
              nvidia.com/gpu: "8"
              cpu: "100"
              memory: "1000Gi"
            requests:
              nvidia.com/gpu: "8"
              cpu: "100"
              memory: "1000Gi"
          volumeMounts:
          - mountPath: /lustre
            name: lustre-storage
          - mountPath: /dev/shm
            name: dshm
        volumes:
        - name: lustre-storage
          persistentVolumeClaim:
            claimName: rl-demo-gpu-lustre-pvc
        - name: dshm
          emptyDir:
            medium: Memory
EOF

Ray kümesi yapılandırmasını uygulayın:

kubectl apply -f ray-cluster.yaml

Küme durumunu doğrulama

Kapsüllerin oluşturulmasını izleyin:

kubectl get pods -w

Baş ve çalışan kapsüllerinin Running olmasını bekleyin.

7. Pekiştirmeli öğrenme iş yükü gönderme

Bu adımda, NeMo-RL GRPO eğitim işini Ray kümenize göndereceksiniz.

Ray kontrol paneline bağlanma

İş göndermek ve metrikleri görüntülemek için Ray Kontrol Paneli'ne bağlanmanız gerekir. Kontrol paneli GKE'de olduğundan Cloud Shell'den erişmek için bağlantı noktası yönlendirme kullanın:

# Run this in a separate Cloud Shell tab or in the background
kubectl port-forward service/${CLUSTER_NAME}-head-svc 8265:8265 &

Yürütme komut dosyasını oluşturma

run_nemo_rl.sh adlı bir dosya oluşturun. Bu komut dosyası, Ray kümesi çalışanlarında yürütülür. Daha önce ayarladığınız ortam değişkenlerini doldurmak için cat << EOF kullanırız.

cat << EOF > run_nemo_rl.sh
#!/bin/bash
set -ex

# Override job runtime conflicts (NeMo-RL passes os.environ to ray.init)
export RAY_OVERRIDE_JOB_RUNTIME_ENV=1

echo "--- Running on Ray Cluster ---"
cd /opt/nemo-rl

# Ensure directories exist on the high-speed Lustre drive
mkdir -p /lustre/huggingface_cache
mkdir -p /lustre/nemo_rl_qwen_72b_ds_cp

echo "Launching NeMo-RL GRPO training..."
uv run python examples/run_grpo_math.py \\
  --config examples/configs/grpo_math_70B_megatron.yaml \\
  policy.model_name='Qwen/Qwen2.5-72B-Instruct' \\
  policy.megatron_cfg.converter_type='Qwen2ForCausalLM' \\
  logger.wandb_enabled=False \\
  cluster.num_nodes=${NUM_NODES} \\
  cluster.gpus_per_node=${GPUS_PER_NODE} \\
  logger.wandb.name='nemo-rl-grpo-test1' \\
  grpo.max_num_steps=20 \\
  grpo.num_generations_per_prompt=8 \\
  grpo.num_prompts_per_step=32 \\
  policy.train_global_batch_size=256 \\
  checkpointing.enabled=True \\
  checkpointing.save_period=2 \\
  checkpointing.keep_top_k=2 \\
  checkpointing.metric_name=null \\
  checkpointing.checkpoint_dir=/lustre/nemo_rl_qwen_72b_ds_cp/nemo-rl-grpo-test1 \\
  data.dataset_name='DeepScaler'
EOF
chmod +x run_nemo_rl.sh

Ray Ignore File oluşturma

Ray'in büyük veya gereksiz dizinleri yüklemesini önlemek için .rayignore dosyası oluşturun:

cat << EOF > .rayignore
xpkclusters/
.git/
*.sh.log
EOF

Çalışma zamanı ortamı yapılandırması oluşturma

Ortam değişkenlerini Ray işine iletmek için bir JSON dosyası oluşturun:

cat << EOF > ray_runtime_env_nemo.json
{
  "env_vars": {
    "HF_TOKEN": "${HF_TOKEN}",
    "WANDB_API_KEY": "${WANDB_API_KEY}",
    "HF_HOME": "/lustre/huggingface_cache",
    "GLOO_SOCKET_IFNAME": "eth0",
    "NCCL_SOCKET_IFNAME": "eth0"
  }
}
EOF

İşi Gönderme

İşi kontrol paneli uç noktasına göndermek için Ray CLI'yı kullanın. ray komutu Cloud Shell'de bulunmuyorsa pip install ray ile yükleyebilirsiniz:

ray job submit \
    --address="http://localhost:8265" \
    --working-dir . \
    --runtime-env ray_runtime_env_nemo.json \
    -- bash run_nemo_rl.sh

Günlüklerin Cloud Shell terminalinizde yayınlandığını görürsünüz. İş, modeli yükler, Ray çalışanlarını başlatır ve GRPO eğitim döngüsünü başlatır.

8. Eğitim performansını izleme

Bu adımda, eğitim ve kontrol noktası oluşturma sırasında Lustre dosya sisteminin performansını gözlemleyeceksiniz.

Eğitim günlüklerini kontrol etme

Eğitim ilerledikçe, kontrol noktalarının /lustre/nemo_rl_qwen_72b_ds_cp/nemo-rl-grpo-test1 konumuna kaydedildiğini belirten günlükler görürsünüz. Kontrol noktası oluşturma işleminin eşzamansız olarak gerçekleştiğini ve Ray çalışanlarını çok uzun süre engellemediğini unutmayın.

Kontrol noktası oluşturma hızını görüntülemek için kaydedilen kontrol noktalarını belirten günlük satırlarını bulun.

Cloud Console'da Lustre Metriklerini Görüntüleme

Lustre örneğinizin metriklerini görmek için:

1. Google Cloud Console'da Managed Service for Lustre'ı arayın.
2. Örnek adınızı (rl-demo-gpu-lustre) tıklayın.
3. Monitoring (İzleme) sekmesini tıklayın.

Burada şunları gözlemleyebilirsiniz:

• İşleme hızı (bayt/sn): Kontrol noktası oluşturma sırasında ani yükselişleri görün.
• Kapasite: Kontrol noktaları tarafından ne kadar alan kullanıldığını izleyin.

Lustre, çok yüksek hızda yazabilir ve kontrol noktalarını en kısa sürede oluşturabilir.

9. Kaynakları Temizleme

Devam eden ödemeleri önlemek için bu adımın tamamlanması son derece önemlidir. Çalışır durumda bırakılan GPU kümeleri ve Managed Lustre önemli maliyetlere neden olabilir.

Bu codelab'de oluşturulan kaynakları silmek için Cloud Shell'de aşağıdaki komutları çalıştırın.

Yönetilen Lustre örneğini silme

gcloud lustre instances delete "${LUSTRE_INSTANCE_ID}" \
    --project="${PROJECT_ID}" \
    --location="${ZONE}" \
    --quiet --async

XPK kullanarak GKE kümesini silme

xpk cluster delete \
    --project="${PROJECT_ID}" \
    --zone="${ZONE}" \
    --cluster="${CLUSTER_NAME}" \
    --force

IP takma adlarını temizleme (isteğe bağlı)

VPC eşleme için oluşturulan IP aralıklarını tamamen temizlemek istiyorsanız:

gcloud compute addresses delete "google-managed-services-${NETWORK_NAME}" \
    --global \
    --project="${PROJECT_ID}" \
    --quiet

Kaynaklar eşzamansız olarak silinir. Durumlarını Cloud Console'da doğrulayabilirsiniz.

10. Tebrikler

GKE ve Yönetilen Lustre ile Güçlendirmeli Öğrenmeyi Ölçeklendirme adlı codelab'i başarıyla tamamladınız.

Öğrendikleriniz

• Spot örnekleriyle GKE GPU kümesi sağlamak için xpk nasıl kullanılır?
• Lustre CSI sürücüsünü ve RayOperator eklentilerini etkinleştirme
• Google Cloud Managed Service for Lustre örneği sağlama
• KubeRay kümesi dağıtma ve Lustre depolama alanı bağlama
• NeMo-RL GRPO eğitim iş yükü gönderme
• Eğitim sırasında depolama alanı performansını gözlemleme

Sonraki adımlar

• Diğer NVIDIA NeMo-RL özelliklerini keşfedin.
• Google Cloud AI Hypercomputer hakkında daha fazla bilgi edinin.
• Managed Service for Lustre belgelerini inceleyin.