GKE Standard'da Yüksek Performanslı Dağıtılmış RL: Eksiksiz Kılavuz

1. Giriş

Bu laboratuvarda, trl kitaplığıyla Grup Göreli Politika Optimizasyonu (GRPO) algoritmasını kullanarak GKE Agent Sandbox'ları (gVisor) ile GKE Standard üzerinde yüksek performanslı dağıtılmış bir takviyeli öğrenme (RL) eğitim döngüsünün nasıl oluşturulacağı, sağlanacağı ve yürütüleceği ayrıntılı olarak açıklanmaktadır.

Amaç, RL eğitim döngüsü sırasında güvenilmeyen, LLM tarafından oluşturulan kodun güvenli bir şekilde nasıl değerlendirileceğini göstermektir. Bunu, düzenleme düzlemini (Ray) yürütme düzleminden (GKE Agent Sandbox'ları) ayırarak gerçekleştiririz.

RL Kod Değerlendirmesinin Teknik Zorluğu

Pekiştirme öğrenimi kullanarak LLM aracı eğitirken (ör. bir modelin birim testlerindeki çıkışını değerlendirerek kod yazması için eğitirken) eğitim döngüsünün, LLM tarafından oluşturulan binlerce güvenilmeyen Python komut dosyasını paralel olarak yürütmesi gerekir. Bu durum kritik sorunlara yol açar:

  1. Kapsül Değişimiyle İlgili Darboğaz: Geleneksel değerlendirme çerçeveleri, her görev için yeni bir Docker kapsayıcısı oluşturur. Bir RL eğitim döngüsü sırasında yüzlerce paralel dağıtım için bunu dinamik olarak yapmak Kubernetes kontrol düzleminde ciddi yüke neden olur. Gecikme, yüksek frekanslı RL eğitimini imkansız hale getirir.
  2. Güvenlik Riski: Standart kapsayıcı çalışma zamanlarında rastgele, LLM tarafından oluşturulan kod çalıştırmak, ana makine işletim sistemi çekirdeğini paylaşır. Tek bir kaçış güvenlik açığı, düğümlerinizin güvenliğini tehlikeye atabilir.
  3. IAM jetonu hırsızlığı: Kubernetes pod'u içinde çalışan LLM tarafından oluşturulan kod, düğüm IAM hizmet hesabı jetonlarını çalmak için bulut sağlayıcının meta veri sunucusunu sorgulayabilir.

Çözüm: Ayrılmış Orkestrasyon ve Yürütme

Bu mimari, düzenlemeyi yürütmeden ayırır:

  • Düzenleyici (Ray): Dağıtılmış bir Ray kümesi, pekiştirmeli öğrenme eğitim döngüsünü yönetir ve dağıtım oluşturmayı dağıtır.
  • Yürütme düzlemi (GKE Agent Sandbox): Ray çalışanları, Kubernetes kapsüllerini dinamik olarak oluşturmak yerine özel bir Sandbox yönlendiricisine basit HTTP çağrıları yapar. Yönlendirici, çalışana anında gVisor (GKE Sandbox) altında çalışan yalıtılmış, önceden ısıtılmış bir container atar.
  • Bir saniyeden kısa gecikme: Sanal alanlar, yönetilen bir SandboxWarmPool içinde önceden ısıtıldığından ve yüksek hızlı bir HTTP ağ geçidi üzerinden yönetildiğinden ortam oluşturma süresi 200 ms'nin altına düşer ve Kubernetes kontrol düzlemi tamamen atlanır.

Laboratuvar Hedefleri

Bu codelab'de şunları öğreneceksiniz:

  • RL döngülerinde güvenilmeyen kodu değerlendirmeye yönelik mimari zorluklar ve çözümler.
  • Verimli kullanıma sunma için özel sanal alan görüntüleri oluşturma
  • GKE Agent Sandbox'ları ve SandboxWarmPool'ları yapılandırma ve kullanma
  • IAM jetonu hırsızlığını önlemek için sanal alanları güvenli bir şekilde yalıtma
  • Orkestrasyonu yürütmeden ayırmak için Ray'i kullanarak SweBench ve TRL ile temel bir RL eğitim işi çalıştırma

2. Küme Oluşturma ve Ön Koşullar

Devam etmeden önce, eğitim iş yükünü yönetmek için yüksek performanslı bir GPU düğüm havuzuna ve Ray Operator'ın yüklü olduğu bir GKE kümesine ihtiyacınız vardır.

Ön koşullar

Bu codelab'de aşağıdaki araçların yüklendiği ve yapılandırıldığı varsayılır:

Ortam Değişkenleri

Öncelikle, bu codelab boyunca kullanılacak ortam değişkenlerini ayarlayın. Aşağıdaki komutlarda makul varsayılan değerler kullanılır ancak bunları, belirli Google Cloud ortamınıza uyacak şekilde değiştirebilirsiniz:

export PROJECT_ID=$(gcloud config get-value project)
export REGION="us-west3"
export ZONE="us-west3-a"
export REPO_NAME="rl-sandbox-repo"

Özel container görüntülerini barındıracak bir Artifact Registry deposu oluşturun:

gcloud artifacts repositories create $REPO_NAME \
    --repository-format=docker \
    --location=$REGION \
    --description="Repository for RL Sandbox images"

Küme Yapılandırması

Yapay zeka iş yükleri için optimize edilmiş bir GKE kümesi (GPUDirect RDMA ağ kablolaması dahil) sağlama hakkında eksiksiz bir kılavuz için resmi dokümanları inceleyin: GKE AI Hypercompute Özel Kümesi Oluşturma

Önemli Ön Koşul: Kümenizi veya belirli bir yürütme düğümü havuzu oluştururken Sandbox sıcak havuzları için gerekli Özel Kaynak Tanımları'nı (CRD'ler) yüklemek üzere --enable-agent-sandbox ve --sandbox type=gvisor işaretlerini ilettiğinizden emin olun.

Kümeniz, GPU'larınız ve Ray operatörünüzün çalıştığını varsayarsak aşağıda, yürütme düzleminin nasıl yapılandırılacağı ve RL döngüsünün nasıl çalıştırılacağı ayrıntılı olarak açıklanmaktadır.

3. Özel görüntüler oluşturma

Yüksek performanslı RL çalıştırmanın önemli bir yönü, bağımlılıkları resimlerinize yerleştirmektir. İki farklı resme ihtiyacımız var: biri modeli çalıştıran GPU çalışanları için, diğeri ise güvenilmeyen değerlendirme kodunu çalıştıran yalıtılmış korumalı alanlar için.

1. GPU çalışan görüntüsünü oluşturma

Ray GPU çalışanı, dil modelini çalıştırmak ve eğitim döngüsünü düzenlemek için kitaplıklara ihtiyaç duyar. Bu görüntüyü resmi vLLM görüntüsünün üzerine oluşturduğumuz için en yeni GPU'ları destekler ve PyTorch/CUDA önceden yüklenmiştir.

Dockerfile.gpu_worker oluşturmak için aşağıdaki komutu çalıştırın:

cat << 'EOF' > Dockerfile.gpu_worker
# ==============================================================================
# Base Image: Use the official vLLM production image. 
# This image comes pre-baked with PyTorch 2.11, CUDA 13.0, and vLLM.
# It supports sm_100 Blackwell GPUs natively!
# ==============================================================================
FROM vllm/vllm-openai:latest

USER root

# Install system dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    numactl \
    libnuma-dev \
    wget \
    ca-certificates \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

# Install Ray, TRL, and Sandbox tools
# TRL does not require compiling flash_attn from source.
RUN pip install --no-cache-dir \
    "ray[default]==2.55.1" \
    "numpy<2.0" \
    gymnasium>=0.28.1 \
    k8s-agent-sandbox>=0.4.6 \
    trl transformers packaging ninja cachetools accelerate datasets peft
EOF

Görüntüyü oluşturup Artifact Registry deponuza aktarın:

export WORKER_REPO="${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO_NAME}/ray-gpu-worker:v1"
docker build -f Dockerfile.gpu_worker -t $WORKER_REPO .
docker push $WORKER_REPO

Not: Bu kılavuz, resim oluşturmak için yerel docker komutlarını kullanır. Resimleri uzaktan oluşturmayı tercih ederseniz bunun yerine Cloud Build'ü (ör. gcloud builds submit kullanarak) kullanabilirsiniz.

2. CPU başlığı resmini oluşturma

Ray baş düğümü yalnızca kümeyi düzenler ve ağır GPU eğitim modellerini çalıştırmaz. Standart CPU düğümlerinizde büyük bir görüntü çekme darboğazını (genellikle 15 GB'tan fazla) önlemek için baş düğümde yalnızca CPU'ya sahip, hafif bir görüntü oluştururuz. Bu görüntüde Ray ve gerekli Python kitaplıkları bulunur ancak CUDA ve vLLM gibi ağır GPU kitaplıkları bulunmaz.

Dockerfile.head oluşturmak için aşağıdaki komutu çalıştırın:

cat << 'EOF' > Dockerfile.head
# ==============================================================================
# Base Image: Use the official Python slim image for the exact patch version.
# This aligns the Python version (3.12.13) with the GPU worker node.
# ==============================================================================
FROM python:3.12.13-slim

USER root

# Install system dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential \
    wget \
    ca-certificates \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

# Install Ray, TRL, and Sandbox tools (CPU versions where applicable)
# We install torch CPU first to avoid pulling the 2GB+ CUDA torch package.
RUN pip install --no-cache-dir torch --index-url https://download.pytorch.org/whl/cpu && \
    pip install --no-cache-dir \
    "ray[default]==2.55.1" \
    "numpy<2.0" \
    gymnasium>=0.28.1 \
    k8s-agent-sandbox>=0.4.6 \
    trl transformers packaging ninja cachetools accelerate datasets peft

# Create a 'ray' user to run the container securely and match Ray conventions
RUN useradd -ms /bin/bash ray
USER ray
WORKDIR /home/ray
EOF

Görüntüyü oluşturun ve aktarın:

export HEAD_REPO="${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO_NAME}/ray-head:v1"
docker build -f Dockerfile.head -t $HEAD_REPO .
docker push $HEAD_REPO

3. Korumalı alan görüntüsünü oluşturma

Çalışma zamanı yüklemesinin anında gerçekleşmesi için sanal alanın, değerlendirdiğimiz görevle ilgili belirli bağımlılıkları olması gerekir. Bu codelab'de, SWE-bench'teki django/django deposundan bir sorun kullanacağız. Depoyu önceden klonlayıp Python ortamlarını önceden oluşturacağız. Böylece model komut dosyalarımız, RL döngüsünde bunları indirerek zaman kaybetmeyecek.

Dockerfile.sandbox oluşturmak için aşağıdaki komutu çalıştırın:

cat << 'EOF' > Dockerfile.sandbox
# Use a stable Debian-based Miniconda image
FROM condaforge/miniforge3:latest

# 1. Install essential system libraries (including sqlite3 for Django tests)
RUN apt-get update && apt-get install -y \
    git \
    build-essential \
    libsqlite3-dev \
    && rm -rf /var/lib/apt/lists/*

# 2. Set up the /workspace directory and grant ownership to the pre-existing non-root 'ubuntu' user (UID 1000)
RUN mkdir -p /workspace \
    && chown -R 1000:1000 /workspace

# 3. Switch to the non-root user
USER ubuntu
WORKDIR /workspace

# 4. Pre-configure Git globally so the agent can run git commands
RUN git config --global user.email "agent@gke-sandbox.local" \
    && git config --global user.name "Agent"

# 5. Pre-clone the repository as the non-root user
RUN git clone https://github.com/django/django.git .

# 6. Pre-build Conda environments and pre-cache common dependencies
# We do NOT run "pip install -e ." here to avoid Python version conflicts with the main branch.
# Instead, we pre-install the heavy dependencies so that runtime installation is instantaneous.
RUN conda create -y -n django-py39 python=3.9 \
    && conda run -n django-py39 pip install --no-cache-dir asgiref sqlparse tzdata pytest pytest-django

RUN conda create -y -n django-py310 python=3.10 \
    && conda run -n django-py310 pip install --no-cache-dir asgiref sqlparse tzdata pytest pytest-django

# --- Add Agent Server ---
# We use a multi-stage build to copy the agent server from the official python-runtime-sandbox image
COPY --from=registry.k8s.io/agent-sandbox/python-runtime-sandbox:v0.1.0 /app /opt/sandbox-agent
USER root
RUN chown -R 1000:1000 /opt/sandbox-agent \
    && /opt/conda/bin/pip install --no-cache-dir -r /opt/sandbox-agent/requirements.txt \
    && sed -i 's|"/app"|"/workspace"|g' /opt/sandbox-agent/main.py
USER ubuntu
# ------------------------

# Prepend the django-py39 conda environment bin to PATH for commands executed inside the container
ENV PATH=/home/ubuntu/.conda/envs/django-py39/bin:$PATH

# Keep the container alive and run the agent server using the system Python
CMD ["/opt/conda/bin/python3", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8888", "--log-level", "trace", "--app-dir", "/opt/sandbox-agent"]
EOF

Görüntüyü oluşturun ve aktarın:

export SANDBOX_REPO="${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO_NAME}/django-sandbox:v1"
docker build -f Dockerfile.sandbox -t $SANDBOX_REPO .
docker push $SANDBOX_REPO

4. Düzenleme ve yürütmeyi yapılandırma

Şimdi düzenleme için Ray kümesini, yürütme için de Sandbox kaynaklarını dağıtıyoruz.

1. Ray Küme Yapılandırması

RayCluster özel kaynağını dağıtın. Kümenizin kullanılabilir kaynaklarının (ör. bellek, CPU veya GPU türü) farklılık gösterebileceğini unutmayın. resources isteklerini ve sınırlarını buna göre ayarlayın.

raycluster.yaml oluşturmak için aşağıdaki komutu çalıştırın. Bu işlem, ortam değişkenlerinizi manifestte otomatik olarak değiştirmek için cat << EOF kullanır:

cat << EOF > raycluster.yaml
apiVersion: ray.io/v1
kind: RayCluster
metadata:
  name: grpo-cluster
  namespace: default
spec:
  rayVersion: "2.55.1"
  headGroupSpec:
    rayStartParams:
      dashboard-host: "0.0.0.0"
    template:
      spec:
        containers:
        - name: ray-head
          image: ${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO_NAME}/ray-head:v1
          ports:
          - containerPort: 6379
            name: gcs-server
          - containerPort: 8265
            name: dashboard
          - containerPort: 10001
            name: client
          resources:
            limits:
              cpu: "2"
              memory: "8Gi"
            requests:
              cpu: "2"
              memory: "8Gi"
  workerGroupSpecs:
  - groupName: gpu-group
    replicas: 1
    minReplicas: 1
    maxReplicas: 1
    rayStartParams: {}
    template:
      spec:
        containers:
        - name: ray-worker
          image: ${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO_NAME}/ray-gpu-worker:v1
          resources:
            limits:
              cpu: "12"
              memory: "120Gi"
              nvidia.com/gpu: "1"
            requests:
              cpu: "12"
              memory: "120Gi"
              nvidia.com/gpu: "1"
EOF

Uygulama:

kubectl apply -f raycluster.yaml

Kümenin oluşturulduğunu ve çalıştığını doğrulayın (bu işlem birkaç dakika sürebilir):

kubectl get raycluster

Beklenen çıktı:

NAME       DESIRED WORKERS   AVAILABLE WORKERS   CPUS   MEMORY   GPUS   STATUS   AGE
rl-cluster   1                 1                                            ready    2m

2. SandboxRouter Yapılandırması

SandboxRouter, yüksek hızlı bir HTTP ağ geçidi olarak işlev görür. Ray çalışanlarından gelen istekleri alır ve bunları anında kullanılabilir gVisor kapsüllerine yönlendirerek daha yavaş olan Kubernetes API sunucusu kapsül yaşam döngüsünü atlar.

sandbox_router.yaml oluşturmak için aşağıdaki komutu çalıştırın:

cat << 'EOF' > sandbox_router.yaml
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: sandbox-claim-manager
rules:
- apiGroups: ["extensions.agents.x-k8s.io"]
  resources: ["sandboxclaims"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
- apiGroups: ["agents.x-k8s.io"]
  resources: ["sandboxes"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: sandbox-claim-manager-binding
  namespace: default
subjects:
- kind: ServiceAccount
  name: default
  namespace: default
roleRef:
  kind: Role
  name: sandbox-claim-manager
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: v1
kind: Service
metadata:
  name: sandbox-router
  namespace: default
spec:
  type: ClusterIP
  selector:
    app: sandbox-router
  ports:
  - name: http
    protocol: TCP
    port: 8080
    targetPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: sandbox-router-deployment
  namespace: default
spec:
  replicas: 2
  selector:
    matchLabels:
      app: sandbox-router
  template:
    metadata:
      labels:
        app: sandbox-router
    spec:
      containers:
      - name: router
        image: us-central1-docker.pkg.dev/k8s-staging-images/agent-sandbox/sandbox-router:latest-main
        ports:
        - containerPort: 8080
        env:
        - name: ALLOW_UNAUTHENTICATED_ROUTER
          value: "true"
EOF

Uygulama:

kubectl apply -f sandbox_router.yaml

Dağıtımın çalıştığını doğrulayın:

kubectl get deployment sandbox-router-deployment

Beklenen çıktı:

NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
sandbox-router-deployment   2/2     2            2           1m

3. SandboxTemplate ve WarmPool Yapılandırması

GKE Agent Sandbox, Sandbox Router'ı kullanarak yalıtılmış ve önceden ısıtılmış container'ların anında atanmasına olanak tanır. Pod'ların hazır kalması için SandboxTemplate ve SandboxWarmPool tanımlarız.

Ortam değişkenlerinizle sandbox_warmpool.yaml oluşturmak için aşağıdaki komutu çalıştırın:

cat << EOF > sandbox_warmpool.yaml
apiVersion: extensions.agents.x-k8s.io/v1alpha1
kind: SandboxTemplate
metadata:
  name: swe-bench-django
  namespace: default
spec:
  podTemplate:
    spec:
      runtimeClassName: gvisor
      securityContext:
        runAsNonRoot: true
        runAsUser: 1000
      nodeSelector:
        sandbox.gke.io/runtime: gvisor
      tolerations:
      - key: sandbox.gke.io/runtime
        operator: Equal
        value: gvisor
        effect: NoSchedule
      containers:
      - name: sandbox
        image: ${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO_NAME}/django-sandbox:v1
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            drop:
            - ALL
        resources:
          requests:
            cpu: "2"
            memory: "4Gi"
          limits:
            cpu: "2"
            memory: "4Gi"
---
apiVersion: extensions.agents.x-k8s.io/v1alpha1
kind: SandboxWarmPool
metadata:
  name: swe-bench-django-warmpool
  namespace: default
spec:
  replicas: 10
  sandboxTemplateRef:
    name: swe-bench-django
EOF

Uygulama:

kubectl apply -f sandbox_warmpool.yaml

SandboxWarmPool'un başlatıldığını doğrulayın:

kubectl get sandboxwarmpool

Beklenen çıktı:

NAME                        READY   AGE
swe-bench-django-warmpool   10      1m

4. Güvenlik İzolasyonu

NetworkPolicy, korumalı alanları kesin olarak yalıtarak GCP meta veri sunucusuna çıkışı engeller ve böylece IAM jetonu hırsızlığını önler.

network_policy.yaml oluşturmak için aşağıdaki komutu çalıştırın:

cat << 'EOF' > network_policy.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: block-metadata-egress
  namespace: default
spec:
  podSelector:
    matchLabels:
      sandbox.gke.io/runtime: gvisor
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0
        except:
        - 169.254.169.254/32
EOF

Politikayı uygulayın:

kubectl apply -f network_policy.yaml

NetworkPolicy'nin oluşturulduğunu doğrulayın:

kubectl get networkpolicy

Beklenen çıktı:

NAME                 POD-SELECTOR     AGE
block-metadata-egress             sandbox.gke.io/runtime=gvisor     1m

5. SweBench ve TRL ile temel RL işi

Küme ve test alanları hazırlandıktan sonra GRPO eğitim döngüsü çalıştırabiliriz. GRPO algoritmasını düzenlemek için trl kitaplığını, oluşturulan kodu izole edilmiş sanal alanlarda değerlendirmek için ise Ray uzak işlevlerini kullanacağız.

Bu codelab'in hızlı bir şekilde tamamlanması için tek bir Django sorunu üzerinde filtreleme yapacağız. Aşağıdaki yönlendirme mantığı, farklı depolar için farklı warmpool'ları nasıl seçeceğinizi gösterir. Bu, tam SWE-bench veri kümesine genişlerken faydalıdır.

Eğitim Senaryosu

train_trl.py oluşturmak için aşağıdaki komutu çalıştırın:

cat << 'EOF' > train_trl.py
import ray
from k8s_agent_sandbox import SandboxClient
from k8s_agent_sandbox.models import SandboxDirectConnectionConfig
from trl import GRPOConfig, GRPOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer
from datasets import load_dataset
import urllib.request
import re

ray.init(ignore_reinit_error=True)

# 1. Define the Ray remote evaluation function
@ray.remote
def evaluate_rollout(code, prompt_data):
    client = SandboxClient(connection_config=SandboxDirectConnectionConfig(api_url="http://sandbox-router.default.svc.cluster.local:8080"))
    
    # Claim a pre-warmed sandbox instantly based on the repo
    repo = prompt_data.get("repo")
    
    # In a full system, you'd route to different warmpools based on repo
    # Here we default to django for our single task
    sandbox = client.create_sandbox(
        template="swe-bench-django",
        warmpool="swe-bench-django-warmpool",
        sandbox_ready_timeout=600
    )
    
    try:
        # Check if the code is correctly formatted
        bash_match = re.search(r"```bash\n(.*?)\n```", code, re.DOTALL)
        if not bash_match:
            return 0.0
            
        script = bash_match.group(1)

        # In a real environment, we would apply the base commit and install here
        # For simplicity, we just execute the script
        import shlex
        script_cmd = f"bash -c {shlex.quote(script)}"
        result = sandbox.commands.run(script_cmd, timeout=60)
        
        # Calculate continuous reward based on test passage ratio
        if result.exit_code == 0:
            return 1.0
        
        # Very simple heuristic reward
        return 0.1
        
    finally:
        # Clean up and release the sandbox back to the pool
        client.delete_sandbox(sandbox.claim_name)

# 2. Define the Reward Function for TRL
def sandbox_reward_func(prompts, completions, **kwargs):
    # Dispatch evaluation to Ray cluster
    futures = [
        evaluate_rollout.remote(completion, {
            "repo": kwargs.get('repo', [])[i] if 'repo' in kwargs else None,
            "base_commit": kwargs.get('base_commit', [])[i] if 'base_commit' in kwargs else None
        }) for i, completion in enumerate(completions)
    ]
    
    # Block and wait for all sandbox evaluations to complete
    rewards = ray.get(futures)
    return rewards

# 3. Setup GRPO Trainer
@ray.remote(num_gpus=1, num_cpus=8)
def train():
    # Load dataset
    dataset = load_dataset("princeton-nlp/SWE-bench_Lite", split="test")
    # Filter to our selected target issue
    dataset = dataset.filter(lambda x: x["instance_id"] == "django__django-15388")
    
    def format_dataset(example):
        files = re.findall(r'^\+\+\+ b/(.+)$', example["patch"], re.MULTILINE)
        target_file = files[0] if files else ""
        
        file_content = ""
        if target_file:
            try:
                github_repo = example["repo"]
                url = f"https://raw.githubusercontent.com/{github_repo}/{example['base_commit']}/{target_file}"
                with urllib.request.urlopen(url) as response:
                    file_content = response.read().decode('utf-8')
            except Exception as e:
                pass
                
        prompt = f"""You are an expert software engineer.
You are given a GitHub issue and the content of the file that contains the bug.
Write an executable bash script that will modify the target file to fix the bug (e.g. using cat << 'EOF' > {target_file} or inline python edits).
Wrap your bash script in ```bash ... ``` tags. Do not output raw python code directly.

Target File: {target_file}

Original File Content:
```python
{file_content}
```

Issue:
{example['problem_statement']}
"""
        return {
            "prompt": prompt,
            "repo": example["repo"],
            "instance_id": example["instance_id"],
            "base_commit": example["base_commit"],
        }
        
    dataset = dataset.map(format_dataset)

    model_name = "Qwen/Qwen2.5-Coder-1.5B-Instruct"
    tokenizer = AutoTokenizer.from_pretrained(model_name)

    training_args = GRPOConfig(
        output_dir="outputs",
        learning_rate=5e-6,
        max_steps=50,
        per_device_train_batch_size=1,
        gradient_accumulation_steps=4,
        num_generations=4,
    )

    trainer = GRPOTrainer(
        model=model_name,
        processing_class=tokenizer,
        reward_funcs=[sandbox_reward_func],
        args=training_args,
        train_dataset=dataset,
    )

    print("Starting GRPO training with GKE Agent Sandboxes...")
    trainer.train()

def main():
    print("Submitting training job to GPU worker...")
    ray.get(train.remote())

if __name__ == "__main__":
    main()
EOF

İşi Kümeye Gönderme

İlk olarak, Ray Head kontrol paneline bağlantı noktası yönlendirme yapın ve eğitim işini yerel makinenizden gönderin:

kubectl port-forward service/grpo-cluster-head-svc 8265:8265 &

ray job submit \
  --address http://localhost:8265 \
  --runtime-env-json '{"working_dir": "."}' \
  -- python train_trl.py

Koşuyu izleme

Koşunuzun ilerleme durumunu izleyebilirsiniz:

  • Ray Kontrol Paneli: Tarayıcınızda http://localhost:8265 adresini açın.
  • Korumalı Alan Talepleri: GKE'nin gVisor altında korumalı alanları dinamik olarak talep etmesini ve serbest bırakmasını izleyin: 
    watch -n 1 "kubectl get sandboxclaims,sandboxes,pods"

6. Sonuç

Tebrikler! GKE Agent Sandbox'ları kullanarak GKE Standard üzerinde yüksek performanslı dağıtılmış bir RL eğitim döngüsünü güvenli bir şekilde başarıyla yapılandırdınız ve yürüttünüz.